& help
This is the MUSH online help facility.
Notes on help descriptions:
[text] - Text enclosed in []'s is optional. The []'s are never typed
in as part of the command.
<parameter> - Information parameter for a command. The <>'s are
never typed in as part of the command.
Syntax of help command:
help [<command>]
To get a list of MUSH topics:
help topics
To get a list of MUSH Commands:
help commands (or @list commands)
If there are any errors in the help text, please notify a Wizard.
& commands
Help available for MUSH Commands:
drop enter examine get give goto
gripe help inventory kill leave LOGOUT
look move news OUTPUTPREFIX OUTPUTSUFFIX page
pose QUIT read say score SESSION
take throw use version whisper WHO
" : ; & # \\
@@ @chown @clone @create @decompile @destroy
@dig @doing @dolist @drain @edit @emit
@entrances @femit @find @force @fpose @fsay
@halt @last @link @list @listmotd @lock
@mvattr @name @notify @oemit @open @parent
@password @pemit @ps @quota @robot @search
@set @stats @sweep @switch @teleport @trigger
@unlink @unlock @verb @wait @whereis
{ 'help commands2' for more }
& commands2
Help available for MUSH Commands (continued):
@aahear @aclone @aconnect @adescribe @adisconnect @adrop
@aefail @aenter @afail @ahear @akill @aleave
@alfail @alias @amhear @amove @apay @asuccess
@atport @aufail @ause @away @charges @cost
@describe @drop @ealias @efail @enter @fail
@filter @forwardlist @idesc @idle @infilter @inprefix
@kill @lalias @leave @lfail @listen @move
@odescribe @odrop @oefail @oenter @ofail @okill
@oleave @olfail @omove @opay @osuccess @otport
@oufail @ouse @oxenter @oxleave @oxtport @pay
@prefix @reject @runout @sex @startup @success
@tport @ufail @use
& topics
Help available on the following Topics:
ARBITRARY COMMANDS ATTRIBUTE OWNERSHIP BEING KILLED BOGUS COMMANDS
BOOLEAN VALUES COMMAND EVALUATION CONTROL COSTS
CREDITS DROP-TO ENACTOR EXITS
FAILURE FLAG LIST FLAGS FUNCTION LIST
FUNCTIONS GENDER GOALS HERE
HOMES LINKING LISTENING LISTS
LOOPING ME MONEY MOVING
OBJECT TYPES PARENT OBJECTS PUPPETS ROBBERY
SACRIFICING SEMAPHORES SPOOFING STACK
SUBSTITUTIONS SUCCESS SWITCHES VERBS
WIZARDS
& drop
Command: drop[/<switch>] <object>
drop[/<switch>] <exit>
The first form removes <object> from your inventory and puts it in your
location, except for the following special cases: Dropping a thing in the
temple sacrifices it, dropping a STICKY thing sends it home, and dropping
a thing in a room with a drop-to sends the thing to the drop-to location.
The second form removes <exit> from your list of exits and adds it to the
list of exits for the current location. Anyone in the same location as
you may then use the exit to travel to the exit's destination. You can
only drop exits when you own the location where you are dropping them.
The following switch is recognized:
/quiet - Don't perform the @odrop/@adrop attributes on the dropped
object. This switch only works if you control the object.
'throw' is the same as 'drop'.
See also: get, @adrop, @drop, @odrop, DROP-TO, SACRIFICING, STICKY.
& enter
Command: enter[/<switch>] <object>
The enter command is used to enter an object. Insides of objects are best
used for vehicles, or storage spaces when you don't have a home (or even
as a floating home). In order to enter an object you must either own it or
it must have its ENTER_OK flag set, and you must also pass the object's
EnterLock (if it has one).
The following switch is recognized:
/quiet - Don't perform the @oenter/@aenter or @oefail/@aefail
attributes on the entered object, and don't perform the
@oxleave attribute on your current location. This switch
only works if you control the object being entered.
See also: leave, @aefail, @aenter, @efail, @enter, @idesc, @lock, @oefail,
@oenter, @oxleave, ENTER_OK.
& examine
Command: examine[/<switches>] <object>[/<wild-attrib>]
Displays all available information about <object>. <object> may be an
object, 'me' or 'here'. You must control the object to examine it, or it
must be set VISUAL. If you do not own the object, you will just see the
name of the object's owner, and optionally any public attributes and
attributes owned by you set on the object.
If an attribute is owned by a player other than the owner of the object,
the number of the attribute owner is shown in parentheses immediately
following the attribute name. The characters + or $ may appear in
parentheses also, to indicate the status of the attribute:
+ - The attribute is locked, it does not change ownership when the
object is @chowned and may not be modified.
$ - The attribute is not checked when looking for $-commands. Note
that the predefined attributes DESC, IDESC, ODESC, FAIL, OFAIL,
SUCC, OSUCC, DROP, ODROP, SEX, and CHARGES are never checked.
{ 'help examine2' for more }
& examine2
If you specify a wildcarded attribute name, then only those attributes
that match are shown. So, 'exam me/v?' will show all your attributes that
start with v and are two characters long.
The following switches are available:
/brief - When examining an object you don't control, show only the
owner's name.
/full - When examining an object you don't control, show any public
attributes set on the object in addition to the owner's name.
/parent - When examining a single attribute (exam <obj>/<attr> where
<attr> contains no wildcard characters), look for the attribute
on <obj>'s parent if it is not present on <obj>.
See also: look, @decompile, VISUAL, ATTRIBUTE OWNERSHIP.
& get
Command: get[/<switch>] <object>
get[/<switch>] <exit>
get[/<switch>] <object>'s <sub-object>
The first form picks up <object> from your location and adds it to your
inventory. It will fail if the object is locked against you, or if you
are inside a player or object that you don't control and which isn't
set ENTER_OK.
The second form takes an exit from your location and adds it to you.
Anyone inside you may then use the exit to travel to the exit's destination.
You may take exits that you own, and exits owned by others in locations that
you own.
The third form takes <sub-object> from <object> and adds it to your
inventory. <object> must be ENTER_OK and <sub-object> must not be locked
against you for this to work. The lock on <object> is not checked.
{ 'help get2' for more }
& get2
The following switch is recognized:
/quiet - Don't perform the @osucc/@asucc or @ofail/@afail attributes
on the target object. This switch only works if you control
the object.
<object> and <sub-object> may be either players or things.
'take' is the same as 'get'.
See also: drop, @afail, @asucc, @fail, @ofail, @osucc, @succ, ENTER_OK,
FAILURE, SUCCESS.
& give
Command: give <player>=<amount/object>
Gives player the specified amount of money or <object>. You can't give
someone money if their new total would be greater than 10000 (No reason to
get greedy). You may also give players objects, but the other player must
be set to ENTER_OK to recieve something you give.
See also: @apay, @cost, @opay, @pay, ENTER_OK.
& goto
Command: goto[/<switch>] <direction>
goto[/<switch>] home
<direction>
home
Moves you in the specified direction, assuming that the direction is not
locked against you. 'move home' is a special command that returns you to
your home. The word 'move' may be omitted.
The following switch is recognized:
/quiet - Don't perform the @osucc/@asucc/@odrop/@adrop or @ofail/@afail
attributes on the exit being used. This switch only works if
you control the exit.
'move' is the same as 'goto'.
See also: enter, home, leave,
& gripe
Command: gripe <complaint>
Writes <complaint> to the game's log file for the game maintainers to see.
A much better way of complaining about something is to talk with one of the
wizards, as the game maintainer may not read the log for a long time, if
at all.
See also: WIZARDS.
& inventory
Command: inventory
Lists what you are carrying and how much money you have.
& kill
Command: kill <player> [=<cost>]
Attempts to kill the specified player. Killing costs <cost> coins, which
gives you a <cost>% chance of killing the player. Thus, spending 100
coins always works (except against wizards and immortals, who can never be
killed). Players cannot be killed in rooms which have been set HAVEN or
which they control. If you don't specify a cost, the default is 10 (for a
10% chance of success). The player, if killed, receives <cost>/2 coins in
insurance.
See also: @akill, @kill, @okill, BEING KILLED, IMMORTAL, WIZARD.
& leave
Command: leave[/<switch>]
This command leave allows you to exit an object you have entered, arriving
in the same location as the object. You may not leave an object if you fail
that object's LeaveLock (but you may still @teleport out, use an exit inside
the object, or go home).
The following switch is recognized:
/quiet - Don't perform the @oleave/@aleave or @olfail/@alfail
attributes on the entered object, and don't perform the
@oxenter attribute on your new location. This switch
only works if you control your current location.
See also: enter, @lock, ENTER_OK, @aleave, @alfail, @leave, @lfail, @oleave,
@olfail, @oxenter.
& LOGOUT
Command: LOGOUT
Disconnects you from your character without breaking the network connection
to the game. You may then log in to another character. The LOGOUT command
must be entered in all capitals.
See also: QUIT.
& look
Command: look [<object>]
Displays the description of <object>, or the room you're in if you don't
specify an object. Specifying object as <name> or #<dbref> or 'me' or
'here' is legal. You can also use look to look at objects held by other
people, just use 'look <person>'s <object>'.
'read' is the same as 'look'.
See also: @adesc, @describe, @odesc.
& move
Command: move[/<switch>] <direction>
move[/<switch>] home
<direction>
home
Moves you in the specified direction, assuming that the direction is not
locked against you. 'move home' is a special command that returns you to
your home. The word 'move' may be omitted.
The following switch is recognized:
/quiet - Don't perform the @osucc/@asucc/@odrop/@adrop or @ofail/@afail
attributes on the exit being used. This switch only works if
you control the exit.
'goto' is the same as 'move'.
See also: enter, home, leave.
& news
Command: news [<topic>]
Shows you the current news for the MUSH. It is highly recommended that
you check the news daily for new information. Otherwise, the wizards will
have no pity on you for messing up with the new commands.
& OUTPUTPREFIX
Command: OUTPUTPREFIX <string>
Causes <string> to be output on a line by itself before printing the
results of each command. This command is intended for use by external
robot programs, and may be restricted to players whose ROBOT flag is set.
The OUTPUTPREFIX command must be entered in all capitals.
See also; @robot, OUTPUTSUFFIX, ROBOT.
& OUTPUTSUFFIX
Command: OUTPUTSUFFIX <string>
Causes <string> to be output on a line by itself after printing the results
of each command. This command is intended for use by external robot
programs, and may be restricted to players whose ROBOT flag is set.
The OUTPUTSUFFIX command must be entered in all capitals.
See also; @robot, OUTPUTPREFIX, ROBOT.
& page
Command: page <player> [=[<control>]<message>]
This command sends <message> to <player>. If you do not specify a message,
it tells a player that you are looking for them, and tell the player where
you are. You may use either the player's name or alias, and you may also
give a string that uniquely matches the start of a player's name on the WHO
list.
You can format the message one of several ways by specifying ':', ';', or
'"' as the first character of the message. ':' and ';' format the message
as 'From afar, <player> <message>', with ';' omitting the space between
<player> and <message>. '"' formats the message in normal page format
(this is the default).
If your Idle attribute is set to something, then it is sent to anyone
who successfully pages you. This is useful for when you are away from
your terminal for a short while.
{ 'help page2' for more }
& page2
You can selectively disable pages from certain players with the '@lock/page'
command (players must pass the lock in order to page you). If someone
cannot page you, they will be sent a message including of your Reject
attribute if they try. If someone pages you while you are not connected,
they are sent a message including your Away attribute.
See also: pose, say, whisper, :, ;, ", @pemit, @away, @idle, @reject.
& pose
Command: pose[/<switches>] <message>
Displays <message> to everyone in your current room, preceded by your name
and optionally a space. Example: the command 'pose jumps for joy' produces
'<yourname> jumps for joy'.
The following switches are available:
/default - (default) Put a space between your name and the message
(ie, display '<name> <message>').
/nospace - Don't put a space between your name and the message
(ie, display '<name><message>').
See also: page, say, whisper, :, ;, ".
& QUIT
Command: QUIT
Logs you out and disconnects you from the game. Must be in all capitals.
See also: LOGOUT.
& read
Command: read [<object>]
Displays the description of <object>, or the room you're in if you don't
specify an object. Specifying object as <name> or #<dbref> or 'me' or
'here' is legal. You can also use look to look at objects held by other
people, just use 'read <person>'s <object>'.
'look' is the same as 'read'.
& ;
Command: ;<message>
This command is much like the ':' command, except that no space is inserted
between your name and the action. Example: the command ';'s watch beeps.'
produces '<youname>'s watch beeps.'.
Warning: This command does not work in command lists run from an attribute
because the ';' is treated as the command separator. Use pose/nospace
instead.
See also: page, pose, say, whisper, :, ".
& :
Command: :<message>
Displays <message> to everyone in your current room, preceded by your name
and a space. Example: the command ':jumps for joy' produces
'<yourname> jumps for joy'.
See also: page, pose, say, whisper, ;, ".
& "
Command: "<message>
Says <message> out loud to everyone in your current room. Example:
the command '"Where is the movie theater?' produces
'<yourname> says "Where is the movie theater>"'. Note that the closing
double quote is automatically added.
See also: page, pose, say, :, ".
& #
Command: #<number> <command>
Forces the object whose database number is <number> to perform <command>.
Example: '#1033 move north' forces object #1033 to go north (assuming that
you control it). The same restrictions that apply to @force also apply to
this command.
See also: @force.
& \\
Command: \\<message>
Outputs <message> to everyone in your current room without embellishment.
Example: the command '\\A chill falls over the room.' produces
'A chill falls over the room.'
See also: @emit, @oemit, NOSPOOF.
& say
Command: say <message>
Says <message> out loud to everyone in your current room. You can also
use '"<message>'.
See also: page, pose, whisper, :, ;, ".
& score
Command: score
Displays how much money you have. Helpful to see if any machines are
looping.
See also: @ps, LOOPING.
& SESSION
Command: SESSION
Displays information on how many characters you have sent and received
during this session, and which (Internal) port you are connected to on the
mush. It must be typed in all uppercase.
Example:
> SESSION
Characters Input---- Characters Output---
Player Name On For Idle Port Pend Lost Total Pend Lost Total
Mortal 00:06 0s 16 0 0 44 156 0 2679
2 Players logged in.
Pending characters are those waiting to be acted on as commands (for input)
or waiting to be sent out over the network (output). Lost characters are
due to overflowing either the MUSH's input or output buffers, either as the
result of running a single command that produces too much output (such as
@find and @search commands that match a large number of objects), or from
typing too much on one line.
Note: your Pending count for output will always be nonzero, as the output
of the SESSION command hasn't been sent out over the network yet.
& take
Command: take[/<switch>] <object>
take[/<switch>] <exit>
take[/<switch>] <object>'s <sub-object>
The first form picks up <object> from your location and adds it to your
inventory. It will fail if the object is locked against you, or if you
are inside a player or object that you don't control and which isn't
set ENTER_OK.
The second form takes an exit from your location and adds it to you.
Anyone inside you may then use the exit to travel to the exit's destination.
You may take exits that you own, and exits owned by others in locations that
you own.
The third form takes <sub-object> from <object> and adds it to your
inventory. <object> must be ENTER_OK and <sub-object> must not be locked
against you for this to work. The lock on <object> is not checked.
{ 'help take2' for more }
& take2
The following switch is recognized:
/quiet - Don't perform the @osucc/@asucc or @ofail/@afail attributes
on the target object. This switch only works if you control
the object.
<object> and <sub-object> may be either players or things.
'get' is the same as 'take'.
See also: drop, @afail, @asucc, @fail, @ofail, @osucc, @succ, ENTER_OK,
FAILURE, SUCCESS.
& throw
Command: throw[/<switch>] <object>
throw[/<switch>] <exit>
The first form removes <object> from your inventory and puts it in your
location, except for the following special cases: Dropping a thing in the
temple sacrifices it, dropping a STICKY thing sends it home, and dropping
a thing in a room with a drop-to sends the thing to the drop-to location.
The second form removes <exit> from your list of exits and adds it to the
list of exits for the current location. Anyone in the same location as
you may then use the exit to travel to the exit's destination. You can
only drop exits when you own the location where you are dropping them.
The following switch is recognized:
/quiet - Don't perform the @odrop/@adrop attributes on the dropped
object. This switch only works if you control the object.
'drop' is the same as 'throw'.
See also: get, @adrop, @drop, @odrop, DROP-TO, SACRIFICING, STICKY.
& use
Command: use <object>
Uses <object>. Some objects will do interesting, useful, or dangerous
things when used, for instance, using a camera should result in a
picture being taken.
See also: @ause, @ouse, @use.
& version
Command: version
Displays the version of MUSH that is running and the date it was last
rebuilt.
& whisper
Command: whisper <player>=<message>
Whispers the message to the named person, if they are in the same room as
you. No one else can see the message that you whisper.
You can format the message one of several ways by specifying ':', ';', or
'"' as the first character of the message. ':' and ';' format the message
as 'You sense <player> <message>', with ';' omitting the space between
<player> and <message>. '"' formats the message in normal whisper format
(this is the default).
See also: page, pose, say, :, ;, ".
& WHO
Command: WHO <prefix>
Displays a list of players currently connected to the MUSH.
The WHO report tells you how long a player has been on, how long they
have been inactive, and what they are doing (if they have used the @doing
command). If <prefix> is specified, only players whose names start with
<prefix> are listed. The WHO command must be entered in all capitals.
See also: @doing.
& &
Command: &<attribute> <object>[=<value>]
Synonym: @set <object> = <attribute>:[<value>]
Sets the attribute named <attribute> on <object> to <value>. If
<attribute> is not a predefined attribute (like ofail or va), then it is
created. Attributes so created are called user-named attributes.
Attribute names may only contain letters, numbers, and the characters
< -_.@#$^&*~?=+| >, and must start with a letter. The names of user-named
attributes may not be abbreviated (an attempt to get the value of the
attribute will fail, and an attempt to set will create a new attribute).
The & command may be used to set predefined attributes (in this instance,
'&<attr> <object>=<value>' is equivalent to '@<attr> <object>=<value>').
See also: @set.
& @@
Command: @@ <args>
This command does nothing, therefore it is useful for putting comments into
a MUSH program. Be careful that ()'s and {}'s in the (otherwise ignored)
arguments are nested correctly, lest your command-ending ; be trapped
inside.
Example:
@va me=$foobar *:@fo #1234=%0;@@ This controls my foobar puppet.
& @chown
Command: @chown <object>[=<player>]
@chown <object>/<attr>[=<player>]
The first form changes the ownership of <object> to <player> (default is
to yourself). Objects may be things, rooms or exits. To chown things, you
have to be carrying the thing. For rooms or exits, you have to be in the
room. Objects must have the CHOWN_OK flag set before they may be @chowned.
In a room, the command used must be @chown here = <name>, and for an object,
you must be very specific.
The second form changes the ownership of the indicated attribute on <object>
to <player> (default is the owner of the object). You may only @chown
unlocked attributes. You may @chown unlocked attributes on objects that
you own to yourself, and you may also @chown attributes that you own on
objects owned by others to the owner of the object.
When an object is @chowned, all unlocked attributes on the object are
automatically @chowned as well, locked attributes remain owned by their
original owners.
The HALTED flag is automatically set on the new copy of the object.
Players can't be @chowned; they always own themselves.
See also: @lock, @Unlock, CHOWN_OK, ATTRIBUTE OWNERSHIP.
& @clone
Command: @clone[/<switches>] <object>[=<newname/cost>]
Creates an exact duplicate of <object> that is owned by you and (for things
and exits) puts it in your current location. You may have the object put
in your inventory (or your exitlist in the case of cloning exits) by using
the /inventory switch.
You may clone your own objects, plus VISUAL objects owned by others.
The INHERIT and WIZARD bits of the (new) object are cleared when the object
is cloned. If <newname> is specified, it is used as the name instead of
the original name.
If you clone a linked exit, an attempt is made to link the clone to the
same location. Except when using the /inventory switch, you can only clone
exits when you own your current location.
If you clone a room with a drop-to, an attempt is made to link the drop-to
to the same location.
If the original object was owned by you, then the ACLONE attribute is run
in the new attribute, otherwise the new object is set HALTED. Exits and
contents of cloned objects are not cloned.
{ 'help @clone2' for more }
& @clone2
The following switches are available:
/cost - Treat the argument after the = as the cost of the new
object, not the name.
/inherit - Don't reset the INHERIT bit on the new object.
/inventory - Create the new object in your inventory (or your exitlist,
in the case of cloning exits).
/location - Create the new object in your location (default).
/parent - Set the new object's parent to be the template object and
don't copy the attributes.
See also: @create, @decompile, @destroy, VISUAL.
& @create
Command: @create <name> [=<cost>]
Creates a thing with the specified name. Creation costs either <cost>
or 10 coins, whichever is greater. The value of a thing is proportional
to its cost, specifically, value=(cost/5)-1. The value may not be greater
than 100, values that would be greater than 100 are rounded down to 100.
See also: @destroy, SACRIFICING, TYPES OF OBJECTS.
& @decompile
Command: @decompile <thing> [=<newname>]
Dumps the sequence of commands you would have to type to clone <thing>.
This is handy for saving your objects in a text file in case the MUSH dies
a horrible death, or for moving your pride-and-joy creation from one MUSH
to another. @decompile works on all object types.
If you specify <newname>, then the commands emitted will set attributes,
locks, and flags on an object named <newname> and will omit the command
to create the object.
See also: examine, look.
& @destroy
Command: @destroy[/<switches>] <object>
This command destroys <object> and refunds its cost of creation to its
owner. You must own <object> in order to @destroy it, unless its
DESTROY_OK flag is set, in which case anyone holding it may @destroy it.
Rooms, exits, and objects may be destroyed, although the the actual
destruction of rooms is delayed for up to ten minutes and the GOING flag
is set on the victim room. Clearing the GOING flag on the room spares it
from destruction.
The @destroy command will not destroy objects with the SAFE flag set unless
the /override switch is specified.
The following switches are available:
/override - Negate protection offered by the SAFE flag.
See also: DESTROY_OK, SAFE.
& @dig
Command: @dig[/<switches>] <name> [= <exitlist> [, <exitlist>] ]
Creates a new room with the specified name and displays its number. This
command costs 10 coins. If the [= <exitlist>] option is used, an exit will
be opened from the current room to the new room automatically. If the
second <exitlist> option (after the comma) is specified, an exit from the
new room back to the current room with the specified [Exits] name is
opened. Either exit creation may fail if you do not have sufficient
rights to the current room to open or link the new exit.
Example: The command
@dig Kitchen = Kitchen;k;north;n,south;s
will dig a room called Kitchen, and open an exit called 'Kitchen' in your
current room. The ; symbol means that you may enter the exit by typing
'k', 'north' or 'n' also. This command also opens the exit 'south;s' from
'Kitchen' back to where you are. Only the first Exit name is displayed in
the Obvious exits list.
If you specify the /teleport switch, then you are @teleported to the
room after it is created and any exits are opened.
See also: @destroy, @link, @open, LINKING, TYPES OF OBJECTS.
& @doing
Command: @doing[/<switches>] [<message>]
Sets your doing message, which appears after your name in the WHO report.
The following switches are available:
/message - Sets your Doing string in the WHO report. (default)
/poll - Displays the current Doing poll from the WHO report.
See also: WHO.
& @dolist
Command: @dolist <list>=<action>
<list> is a space-separated list of strings, which can be object numbers,
attributes, or arbitrary words. <action> is a command to perform once for
each item in <list>, replacing the special symbol ## with the corresponding
item from <list>. This command is particularly handy with lcon() and
lexits(). A few examples:
@dolist [lcon(here)] = "[name(##)](##)
@dolist [lcon(here)] = @switch [get(##/last)]=*1990*,"[name(##)]
@va me = va vb vc
@dolist [get(me/va)] = @emit [get(me/##)]
@dolist Frodo Bilbo Gandalf = page ## = HELP!!!! I've fallen into a pit.
See also: iter().
& @drain
Command: @drain <object>
Discards all commands waiting on the semaphore <object> and resets the
semaphore to its initial state.
See also: @notify, @ps, SEMAPHORES
& @edit
Command: @edit <object>/<wild-attr> = <search>,<replace>
@edit <object>/<wild-attr> = ^,<text>
@edit <object>/<wild-attr> = $,<text>
This command edits the contents of one or more attributes of an object,
eliminating the need to retype a long attribute in order to make a simple
change. In the first form, all occurrences of <search> in the specified
attribute of the named object are replaced with <replace>. Use curly
braces ({ and }) around <search> or <replace> if they contain commas.
The second and third form prepend and append <text> to the selected
attributes, respectively.
If <wild-attr> contains wildcard characters, then all attributes that
match are edited.
& @emit
Command: @emit[/<switches>] <message>
Sends <message> to everyone in your current location without prefixing it by
your character name. You can also send the message to everyone in the room
that contains the object you are inside with the /room switch.
The following switches are available:
/here - Sends the message to everyone in the same location as you.
/room - Sends the message to everyone in the room that contains the
object you are in. Starting from your location, this switch
'leaves' objects until it reaches a room, and @emits the message
there.
If both switches are specified, the message is sent to both places. If
neither is specified, /here is assumed.
Some MUSHes may restrict the use of this command.
See also: @femit, @oemit, @pemit, SPOOFING.
& @entrances
Command: @entrances [<object>]
Lists links from elsewhere to the specified object (default: your current
room). For rooms, exits and drop-to's, leading to the room and players
and objects whose home is in the room are listed. For players and objects,
lists exits leading to them. Because this command is computationally
expensive, it costs 100 coins.
See also: @link, @unlink.
& @femit
Command: @femit <object>=<message>
Forces <object> to emit <message>. This command is similar to the command
'@force <object> = @emit <message>', except that it will work so long as
you own the object, whereas @force may fail if the object has its INHERIT
flag set and the object performing the @force does not.
See also: @emit, @fpose, @fsay, INHERIT, SPOOFING.
& @find
Command: @find [name]
Displays the name and number of every room, thing, or player that you
control whose name matches <name>. Because the command is computationally
expensive, it costs 100 coins.
See also: @search.
& @force
Command: @force <player/object>=<command>
Forces the game to act as though <player/object> had entered <command>.
You may only force objects that you control. Objects may not force players
unless either the object or the player has their INHERIT flag set, and
objects that do not have their INHERIT flag set may not force objects that
do. If the victim is specified by number, you may use an alternate form
of the command, '#<number> <command>'.
See also: puppets.
& @fpose
Command: @fpose[/<switches>] <object>=<message>
Forces <object> to pose <message>. This command is similar to the command
'@force <object> = :<message>', except that it will work so long as you
own the object, whereas @force may fail if the object has its INHERIT flag
set and the object performing the @force does not.
The following switches are available:
/default - (default) Put a space between the name of the object and
the message (ie, send '<name> <message>').
/nospace - Don't put a space between the name of the object and the
message (ie, send '<name><message>').
See also: @femit, @fsay, pose, :, ;, INHERIT.
& @halt
Command: @halt [<object>]
Halts all commands being run by <object>, or by the object running the
command if no <object> is given. If the object to be halted is a player,
then all commands being run by objects owned by that player are halted.
Use this command to stop runaway objects and infinite loops.
The process of halting an object involves removing all commands waiting
to be run by the object from the queue and refunding the queue deposit.
Halting an object does not affect commands waiting on it as a semaphore.
See also: @drain, @notify, kill, HALTED, SEMAPHORES.
& @last
Command: @last <player>
This command displays a short 'connection history' for <player>, showing
recent successful and failed connection attempts, as well as the total
number of successful and failed connections.
You can only display information about yourself.
& @link
Command: @link <object>=#<number>/here/home
When used on a player or a thing, this command sets the object's home
to the indicated location. The destination must be owned by you or be an
ABODE room, and you must pass the destination's LinkLock.
When used on a room, this command sets the room's drop-to, where objects
dropped in the room go. The destination must be a room that is either owned
by you or is LINK_OK, and you must pass the destination's LinkLock.
For exits, this command sets the destination if the exit is currently
unlinked, you control the destination or it is set LINK_OK, and you pass the
destination's LinkLock. You can @link an unlinked exit regardless of who
owns it or the lock set on it, you are made the owner if you successfully
link to the destination. Linking an exit costs 1 coin, and if the exit was
owned by someone else, you also reimburse the the former owner 1 coin
(making the total cost to you 2 coins).
{ 'help @link2' for more }
& @link2
Note that in all the above cases that it is the player performing the @link
command that must pass the LinkLock, not the object being linked.
Therefore, you should use the '$' lock qualifier if you want to prevent
specific players from linking to your LINK_OK locations, as simply locking
against '*<playername>' does not lock out their puppets.
See also: @dig, @open, @unlink, DROP-TOS, HOMES, LINKING.
& @list
Command: @list [<option>]
Lists information from internal databases. Information is available
about the following options:
attributes - Valid object attributes.
commands - Commands that you may use (excluding the
attribute-setting commands as well as any exits, and
$-commands available).
costs - Lists the costs associated with many commands and
actions.
default_falgs - Lists the flags that new objects receive by default
when created.
flags - Lists the name and letter of all the flags.
functions - Lists all the available functions.
options - Lists several global options and limits.
switches - Lists what commands support switches and the switches
that they do support.
The information provided by the @list command is definitive, as it reads
the internal tables to produce the information it displays. Specifying
@list with no argument lists the options you may use.
& @listmotd
Command: @listmotd
Displays the current message-of-the-day. Note that it is displayed when
you connect to your character.
& @lock
Command: @lock[/<whichlock>] <object>=<key>
@lock <object>/<attrib>
The first form locks <object> to a specific key(s). <object> and <key> can
be specified as <name> or #<number>, or as 'me' or 'here'. Boolean
expressions are allowed in the key, using '&' (and), '|' (or), '!' (not),
and parentheses ('(' and ')') for grouping. To lock to a player, prefix
their name with '*' (ex. '*Wizard'). Example: '@lock purse = me|*Darling'
locks the object Purse so that only you and the player Darling may take it.
<whichlock> indicates which lock you want to set on the object. If you
don't specify one, you set the Default lock. You can set the following
locks:
DefaultLock: Exits: controls who may traverse the exit to
its destination.
Rooms: controls whether the player sees the SUCC
or FAIL message for the room following the
room description when looking at the room.
Players/Things: controls who may GET the object.
{ 'help @lock2' for more }
& @lock2
EnterLock: Players/Things: controls who may ENTER the object if the
object is ENTER_OK.
GiveLock: Players/Things: controls who may give the object.
LeaveLock: Players/Things: controls who may LEAVE the object.
LinkLock: All but Exits: controls who may link to the location if the
location is LINK_OK (for linking exits or
setting drop-tos) or ABODE (for setting
homes)
PageLock: Players: controls who may page the player.
ReceiveLock: Players/Things: controls who may give things to the object.
TeloutLock: All but Exits: controls who may teleport out of the
location.
TportLock: Rooms: controls who may teleport there if the
room is JUMP_OK.
UseLock: All but Exits: controls who may USE the object, GIVE the
object money and have the PAY attributes
run, have their messages heard and possibly
acted on by LISTEN and AxHEAR, and invoke
$-commands stored on the object.
{ 'help @lock3' for more }
& @lock3
The second form locks the indicated attribute of the named object, so that
when the object is @chowned, the attribute will remain owned by you.
It may also be used when you own an attribute on an object that you do not
own, in this case it prevents the object's owner from @chowning the
attribute to himself, and prevents anyone from modifying or removing the
attribute.
You can now lock to attributes. Example: '@lock thing=sex:m*' will lock
thing to any one whose sex starts with an M. Wild cards, greater than and
less than may be used, for example: '@lock a-f=name:<g' will lock the exit
a-f against any one whose name is higher than f. When checking an
attribute lock, the object trying to pass the lock and all of its contents
are checked against the lock, if any one of these objects passes the
attribute check then the object passes the lock.
You may lock against any attribute, but the lock will fail if the locked
object is not able to read the attribute from the player attempting to use
the object. This will be the case, for instance, if you lock an object
with the lock 've:foobar'. Any object that you own whose ve attribute is
'foobar' will pass the lock, as will objects owned by others on which you
own the ve attribute (if the contents of the ve attribute is 'foobar').
{ 'help @lock4' for more }
& @lock4
You may also require that the player testing the lock either IS the target
object or CARRIES the target object (by default, either will pass), or is
OWNED BY the same player as the target object. To make a carry lock,
prefix the object name with a '+'. Example: '@lock door = +key' keeps you
out unless you carry key. If you are key, you won't be let in. Similarly,
you make an is lock by prefixing the object name with a '='. Example:
'@lock fred-exit = =*fred' keeps everyone but fred from using fred-exit.
Carrying fred won't help. To make an owned-by lock, prefix the object name
with a $, so '@lock/page me=!$*Fred' lets anyone but Fred (and any of Fred's
objects page you. Owned-by locks are useful in page, use, and teleport
locks.
It is also possible to indirectly reference the lock of another object by
prefixing the object name by a '@'. This causes the lock on the object to
be evaluated and the result used. Example: '@lock fly = wings | @#1234'
keeps you from the fly exit unless you have (ore are) the wings or you
pass the lock set on object #1234.
See also: @chown, @unlock, ATTRIBUTE OWNERSHIP.
& @mvattr
Command: @mvattr <object>=<old>,<new>[,<copy1>]...
This command moves attributes around on an object. The attribute <old> is
renamed <new> (and is copied to <copy1>, <copy2> and so on if specified).
If you cannot modify the <old> attribute (for instance if you are trying to
move the Last attribute, or if it were owned by another player), then a new
copy is made and the original is not removed.
See also: @set.
& @name
Command: @name <object>=<new name> [<password>]
Changes the name of <object>. <object> can be a thing, player, exit, or
room, specified as <name> or #<dbref> or 'me' or 'here'. For a player,
it requires the player's password.
& @notify
Command: @notify[/<switches>] <object>[=<count>]
Notifies the semaphore <object>, running the first command that waited on
<object> using the '@wait <object>=<command>' or '
@wait <object>/<time>=<command>' forms of the @wait command. If <count> is
specified, it indicates the number of times the semaphore is notified.
If there are no commands (or less than <count> commands) pending for
<object>, then subsequent @waits will not block until the semaphore count
reaches zero again.
The following switches are available:
/first - (default) Notify the first command waiting on the indicated
semaphore (or the first <count> commands).
/all - Notify all commands waiting on the semaphore and reset the
semaphore count to zero. <count> is ignored.
See also: @drain, @ps, @wait, SEMAPHORES
& @oemit
Command: @oemit <player>=<message>
Emits <message> to everyone in your current location except for <player>.
See also: @emit, @pemit, SPOOFING.
& @open
Command: @open[/<switches>] <direction list> [=<number>[,<direction list>]]
Creates an exit in the specified direction(s). If <number> is specified,
it is linked to that room. Otherwise, it is created unlinked. You or anyone
else may use the '@link' command to specify where the unlinked exit leads.
Opening an exit costs 1 coin. If you specify <number>, linking costs 1 more
coin. You can specify a second direction list (after the comma), which is
automatically opened in the room that the new exit goes TO and which is
linked back to where you are. I.e. @open north;n=#1234,south;s
would open exit 'north;n' from here to #1234, and an exit 'south;s'
from #1234 to here, assuming you have rights to open exits and link to
the rooms in question.
The following switches are available:
/location - Create the exit in your location (default).
/inventory - Create the exit on yourself.
See also: @dig, @link, LINKING.
& @parent
Command: @parent <object> [=<parent>]
This command sets the parent of <object> to <parent> (or clears the parent
if <parent> is omitted. You must control <object>, and must own <parent>.
See also: PARENT OBJECTS.
& PARENT OBJECTS
Topic: PARENT OBJECTS
Parent objects provide a way for several objects to inherit common
attributes, exits, and $-commands from a single object, so that changing
the parent object affects all of its children. When searching for
attributes or exits, first the object itself is checked, and the parent
is checked only if the object does not have what was searched for.
A parent object provides these items to its children:
Attributes: If a child is searched for an attribute that it does not
have, the parent is then searched.
Exits: If a command entered while inside an object does not match
an exit in the object, the parent is searched for matching exits
before checking for internal MUSH commands.
$-commands: When an object is checked for matching $-commands, its
parent is checked as well.
A parent object may itself have a parent, up to a configurable limit
(usually 10 levels). The parent need not be the same type as its children,
and flags and locks are not inherited from parent objects. You may not
create parent loops.
See also: @parent, parent().
& @password
Command: @password <old password>=<new password>
This command changes your password.
& @pemit
Command: @pemit[/switches] <what>=<message>
Emits <message> only to <what>, or to <what>'s contents of the /contents
switch is given. <what> must be either in the same location as you or
be something you own. You can also @pemit to distant players if neither
you or they are HAVEN, and this costs as much as a page <This feature is
not present in all MUSHes>. You cannot @pemit to the contents of
something you don't own.
The following switches are available:
/contents - Send the message to the contents of the named object.
/object - Send the message to the named object.
See also: page, @emit, @oemit, SPOOFING.
& @ps
Command: @ps[/<switches>] [<object>]
Lists information about the commands you have on each of the queues.
Unless the /summary switch is used, this command lists all the commands you
have on the queues, optionally along with their enactor and arguments.
Commands scheduled to be executed at a later time (by the @wait command)
also show the number of seconds until they will be executed and/or the
semaphore on which they are waiting. If <object> is specified, only
commands run by <object> are listed, otherwise all commands run by any of
your objects is listed. A summary of the number of commands listed and the
total number of commands in the queues is also displayed. This command is
useful for identifying infinite loops in programs.
The following switches are available:
/brief - (default) Display a brief summary that shows the semaphore
number, time-to-wait, object running the command, and the
command to be run.
/long - In addition to the informatin in the /brief report, display
the name and number of the object that caused the command
to be run (the enactor) and the arguments to the command.
/summary - Display just the queue counts.
See also: @notify, @wait.
& @quota
Command: @quota
Lists your total building quota and the amount you have remaining.
Creating objects, digging rooms, and opening exits all consume quota.
See also: @create, @dig, @open.
& @robot
Command: @robot <name>=<password>
Creates a robot player owned by you. The robot has its ROBOT flag set, so
it may use the OUTPUTPREFIX and OUTPUTSUFFIX commands that most publicly
available robot programs require. This command costs 1000 coins.
Note that some sites do not restrict OUTPUTSUFFIX and OUTPUTPREFIX to
robots.
See also: OUTPUTPREFIX, OUTPUTSUFFIX, ROBOT, TYPES OF OBJECTS.
& @search
Command: @search [<player>] [<class>=<restriction>]
Displays information about objects that meet the search criteria.
Because this command is computationally expensive, it costs 100 coins.
<player> restricts the search to the named player, while <class>
and <restriction> control the objects listed as follows:
TYPE - Restricts to objects of the indicated type (OBJECTS, ROOMS,
EXITS, PLAYERS).
NAME - Restricts to objects whose names start with <restriction>.
OBJECTS - A combination of TYPE=OBJECT and NAME=<restriction>.
ROOMS - A combination of TYPE=ROOM and NAME=<restriction>.
EXITS - A combination of TYPE=EXIT and NAME=<restriction>.
PLAYERS - A combination of TYPE=PLAYER and NAME=<restriction>.
FLAGS - Restricts to objects which have the flags listed in
<restriction> set..
EVAL - Evaluates the restriction for each object, replacing ##
with the object's database number. Evaluations that return
TRUE (ie, not 0 or #-1) are selected.
EOBJECT - A combination of TYPE=OBJECT and EVAL=<restriction>.
EROOM - A combination of TYPE=ROOM and EVAL=<restriction>.
EEXIT - A combination of TYPE=EXIT and EVAL=<restriction>.
EPLAYER - A combination of TYPE=PLAYER and EVAL=<restriction>.
{ 'help @search2' for more }
& @search2
Except when getting lists of players ('@search type=player' or
'@search flags=P'), you may only search for objects that you own.
Examples:
@search flags=PWc <-- search for connected wizards.
@search type=rooms <-- list all rooms owned by me.
@search eval=gt(money(##),10) <-- search for things worth more than 10.
See also: @find, search().
& @set
Command: @set <object>=[!]<flag>
@set <object>=<attribute>:<value>
@set <object>/<attr>=[!]<attrflag>
The first form sets (or clears) the indicated flag on <object>, the
second form sets the <attribute> attribute on <object> to <value>,
creating a new user-named attribute if there is no attribute named
<attribute>, and the third form sets (or clears) an attribute flag on
the <attr> attribute of <object>.
When setting attributes on an object, you may also use the command
'@<attribute> <object> = <value>' if the attribute is a predefined
attribute. You may also use the command '&<attribute> <object> = <value>'
to set either predefined attributes or user-named attributes. Either of
these is equivalent to the second form of the @set command.
The following flags may be set using the third form of the @set command:
no_command - prevent $-commands and ^-patterns defined in the attribute
from being performed.
See also: @lock, @lock, examine, FLAGS, &.
& @stats
Command: @stats[/all] [<player>]
Display the number of objects in the game. @stats/all gives a
breakdown by object types. If <player> is specified, the breakdown
for the named player is given. You may only list individual counts
for yourself. If invoked with no arguments or switches this command is
free, but if you specify either /all or <player>, then this command costs
100 coins to run, because it is computationally expensive.
See also: stats().
& @sweep
Command: @sweep[/<switches>]
This command tells you all of the objects, players, and exits that are
listening in the room you are currently in, as well as the objects you are
carrying. Most objects only listen for a particular string or phrase, so
they normally do not pose a problem if you need privacy. You will have to
be careful of players, puppets, and audible exits since they will hear
everything you say and do. There are several switches that may be used to
limit the type of listeners that are checked for. They are:
/here - Check the room I am in.
/inventory - Check my inventory.
/exits - Check exits in the room.
/commands - Check for objects that have $-commands set on them.
/connected - Check for connected players and their puppets.
/listeners - Check for objects with @listen set to something.
/players - Check for players and their puppets, whether or not they
are connected.
The default is to search for everything. If you specify one or more
switches from either category (either location or listener type then only
that location or listener type is checked.
See also: @listen, AUDIBLE, PUPPETS.
& @switch
Command: @switch[/<switches>] <string>=<t1>,<c1> [,<tN>,<cN>]... [,<cD>]
Compares <string> against the targets <t1>, <t2>, etc, until a match is
found, at which time the corresponding list of commands is performed.
Wildcards, and the < and > operators are allowed in the targets. By
default, any list whose target matches the string is executed (the targets
are not mutually exclusive). If no target matches, the default list
<cD> is executed.
The following switches are available:
/all - (default) Perform the actionlists associated with all targets
that match <string>.
/first - Perform only the actionlist associated with the first target
that matches <string>.
& @teleport
Command: @teleport [<object>=] <room/exit>
Teleports <object> (or you, if not specified) to <room>. <object> must be
a thing or a player. You must control the destination, or it must be set
JUMP_OK, and the object being teleported must pass the TeloutLock for its
present location. You can teleport objects that you control, if you control
the room you are in you can also teleport objects owned by others to another
room you control, a JUMP_OK room, or out an exit you control.
If the destination room has a drop-to, the object will go to the drop-to
instead.
See also: JUMP_OK.
& @trigger
Command: @trigger <object>/<attr> [=<param> [, <param>]... ]
Invokes an action list stored in an attribute on an object. The triggering
object becomes the enactor and the positional parameters %0 through %9
are set to the supplied parameters.
See also: LOOPING.
& @unlink
Command: @unlink <room/exit>
This command removes drop-tos on rooms and clears the destination on exits.
Once unlinked, an exit may be taken over by anyone with the @link command.
See also: @link, LINKING.
& @unlock
Command: @unlock <object>
@unlock <object>/<attrib>
The first form removes the lock on <object>, so that anyone may pass
through (if an exit) or pick it up (if a player or an object).
The second form clears the locked flag on the indicated attribute of the
named object. This allows the attribute to change ownership to the new
owner automatically when the object is @chowned, and allows the owner
of the object to @chown the attribute to themself or to overwrite it.
You must own the attribute to be unlocked, but you do not need to own the
object.
See also: @chown, @lock, ATTRIBUTE OWNERSHIP.
& @verb
Command: @verb <victim>=<actor>,<what>,<whatd>,<owhat>,<owhatd>,<awhat>,
<args>
This command looks up the <what>, <owhat>, and <awhat> attributes on
<victim>, and then does the following:
- Sends the contents of <what> to <actor>. If <victim> does not have a
<what> attribute, sends the <whatd> string instead.
- Sends the contents of <owhat> to everyone in the same room as
<actor>, except for <actor> and <victim>. If <victim> does not have
an <owhat> attribute, sends the <owhatd> string instead.
- <victim> performs the <awhat> attribute, if it exists.
Note that this command provides a way to implement user-defined verbs that
are similar to the predefined verbs such as use, pay, or drop.
You must control both the victim and the actor. Note that unless player #1
invokes the @verb command, s/he cannot be affected by a @verb command
(because only #1 controls #1).
{ 'help @verb2' for more }
& @verb2
Here is a description of the arguments to @verb:
victim - The object that is searched for attributes, and which runs the
<awhat> attribute if it is found.
actor - The object that 'did' the verb, this is the value for %#/%n/etc
in substitutions, and this object's name is included in the
message to others in the same location.
what - The name of the attribute containing the message to be delivered
to the actor.
whatd - The message to deliver to the actor if the victim does not have a
<what> attribute.
owhat - The name of the attribute containing the message (prefixed by the
actor's name) that is sent to everyone in the room with the actor.
owhatd - The message (prefixed by the actor's name) to deliver to others
in the room with the actor if the victim does not have an <owhat>
attribute.
awhat - The name of the attribute that is to be executed by the victim.
args - The comma-separated arguments to be passed for substitution
(%0-%9). If there is more than one argument, enclose all the
arguments within curly braces. Any argument that contains an
embedded comma needs to be enclosed in curly braces as well.
{ 'help @verb3' for more }
& @verb3
Examples:
> &xtest test1=You just xtested test1.
> &oxtest test1=just xtested test1.
> &axtest test1="I was xtested. Yikes. Arg1=%0, Arg2=%1, Arg3=%2.
> @verb test1=me,xtest,XTEST DFLT,oxtest,OXTEST DFLT,axtest,{a,b c,de}
You just xtested test1.
test1 says "I was xtested. Yikes. Arg1=a, Arg2=b c, Arg3=de."
> &xtest test1
> @verb test1=me,xtest,XTEST DFLT,oxtest,OXTEST DFLT,axtest,{a,b c,de}
XTEST DFLT
test1 says "I was xtested. Yikes. Arg1=a, Arg2=b c, Arg3=de."
> @fo test1={@verb test1=me,xtest,XTEST D,oxtest,OXTEST D,axtest,{a,b,de}}
test1 just xtested test1.
test1 says "I was xtested. Yikes. Arg1=a, Arg2=b, Arg3=de."
See also: locate().
& @wait
Command: @wait <seconds>=<command>
@wait <object>[/<seconds>]=<command>
The first form of @wait executes <command> after <seconds> seconds. The
second form increments the semaphore count for <object> and executes
<command> after <object> is notified with the @notify command. If the
semaphore count for <object> is negative (because it has been notified more
times than it has been waited on), then <command> is run immediately.
If <seconds> is specified in the second form, the command is automatically
run after <seconds> seconds even if the semaphore isn't notified. This
command charges a deposit of 10 coins, which is refunded when <command>
is executed.
See also: @drain, @notify, @notify_all, @ps, SEMAPHORES.
& @whereis
Command: @whereis <player>
Tells you the location of the named player. If you wish to remain
unlocatable, set your UNFINDABLE flag. The person being located will get
a message to inform them that you have successfully or unsuccessfully
located them.
See also: UNFINDABLE, loc().
& @aahear
Command: @aahear <object> = <command-list>
Attribute: Aahear
An Aahear on an object is activated whenever the listen pattern
matches anything done/said by anything else in the room, including
itself. (The Ahear ignores itself, helpful for keeping machines from
triggering itself)
Example: @aahear listener = "I heard someone (maybe me?) say the word!
See also: @ahear, @amhear, @listen.
& @aclone
Command: @aclone <object> = <command-list>
Attribute: Aclone
Sets the actions to be taken by a new object that has just been created
as the result of a @clone command. The contents of the Aclone attribute
are run by the new object and not by the old object.
This attribute is only meaningful for things, and will never be
automatically triggered on other object types.
Example: @aclone Time bomb = @wait 600=@trig me/va;@wait 10=@trig me/vb
@va time bomb = :EXPLODES with a thundering roar;@destroy me
@vb time bomb = :ticks.; @wait 10=@trig me/vb
See also: @clone.
& @aconnect
Command: @aconnect <object> = <command-list>
Attribute: Aconnect
Sets the actions to be taken by a player right after connecting to the
game. This attribute is only meaningful for players, and will never be
automatically triggered on other object types.
Example: @aconnect me = check.my.mailbox
See also: @adisconnect.
& @adescribe
Command: @adescribe <object> = <command-list>
Attribute: Adescribe
Sets the actions to be taken when <object> is looked at.
Example: @adesc kitten = :rubs against %n's legs affectionately.
See also: look, @desc, @idesc, @odesc.
& @adisconnect
Command: @adisconnect <object> = <command-list>
Attribute: Adisconnect
Sets the actions to be taken by a player right after disconnecting from
the game.
This attribute is only meaningful for players, and will never be
automatically triggered on other object types.
Example: @adisconnect me = home
See also: @aconnect.
& @adrop
Command: @adrop <object> = <command-list>
Attribute: Adrop
Sets the action to be taken by an object when it is dropped, or by an exit
when it is successfully used.
Example: @adrop plastique = kill %n=100; @destroy me
See also: drop, @drop, @odrop, DROP-TO, EXITS.
& @aefail
Command: @aefail <object> = <command-list>
Attribute: Aefail
Sets the action to be taken by an object when someone tries to enter it
but fails because the object is not ENTER_OK or the player fails the
object's enter lock.
The enter lock only affects the 'enter' command and its aliases (set via
the @ealias command), it does not affect exits that lead to the object or
teleporting in.
This attribute is meaningful for players and things, and will never be
automatically triggered on rooms or exits.
Example: @aefail car = @emit ;'s alarm starts wailing when %n tries
to break in.
See also: @aenter, @efail, @ealias, @enter, @oefail, @oenter, enter,
ENTER_OK.
& @aenter
Command: @aenter <object> = <command-list>
Attribute: Aenter
Sets the action to be taken by an object or room when someone enters it,
whether by using an exit, the enter or leave commands, or by teleporting.
This attribute is meaningful for players, things, and rooms, and will never
be automatically triggered on exits.
Example: @aenter car = :starts its engine, eagerly awaiting a road trip.;
"Beep Beep!
See also: enter, @enter, @oenter, ENTER_OK.
& @afail
Command: @afail <object> = <command-list>
Attribute: Afail
Sets the actions to be taken by an object when someone fails to pick it up
(because it was locked), by an exit when someone fails to pass through it,
or when someone looks at a room and fails the room's lock.
Example: @afail vase = :falls to the floor and smashes to pieces.;
@destroy me
See also: @fail, @ofail, FAILURE.
& @ahear
Command: @ahear <object> = <command-list>
Attribute: Ahear
Sets the actions to be taken after the object hears a string that matches
the pattern in the Listen attribute which was not produced by the object
itself. Messages that are produced by the object itself are ignored.
Example: @ahear clock = "The time is now [time()]. >> BONNNNGGGGG <<
See also: @aahear, @amhear, @listen.
& @akill
Command: @akill <object> = <command-list>
Attribute: Akill
Sets the actions to be taken by an object after it is killed and has
returned to its home.
This attribute is only meaningful for players and things, and will never be
automatically triggered on other object types.
Example: @akill lion = south; :leaps onto %n, roaring loudly.;kill %n=100
See also: kill, @kill and @okill, BEING KILLED, IMMORTAL, WIZARD.
& @aleave
Command: @aleave <object> = <command-list>
Attribute: Aleave
Sets the action to be taken by an object or room when someone leaves it,
whether by using an exit, the enter or leave commands, or by teleporting.
This attribute is meaningful for players, things, and rooms, and will never
be automatically triggered on exits.
Example: @aleave car = :stops to let %n out.;:revs its engine, hoping
another brave soul would like a ride.
See also: leave, @leave, @oleave.
& @alfail
Command: @alfail <object> = <command-list>
Attribute: Alfail
Sets the action to be taken by an object when someone tries to leave it
but fails because the player fails the object's leave lock.
The leave lock only affects the 'leave' command and its aliases (set via
the @ealias command), it does not affect going home, using an exit in the
location, or teleporting out.
This attribute is meaningful for players and things, and will never be
automatically triggered on rooms or exits.
Example: @alfail box = :rattles around as %n tries to escape.
See also: @aleave, @lalias, @leave, @lfail, @oleave, @olfail, leave.
& @alias
Command: @alias <object> = <name>
Attribute: Alias
Provides an alternate name by which the object is known. The alternate
name is only used for players when referenced as '*<name>' or by commands
that only take playernames (such as page or @stats), for all other object
types it is purely documentary.
When setting an alias for a player, the alias is checked to see that it
is both a legal player name and not already in use. Only if both checks
succeed is the alias set. These checks are not made for things, exits,
or rooms.
& @amhear
Command: @amhear <object> = <command-list>
Attribute: Amhear
Sets the actions to be taken after the object hears a string that matches
the pattern in the Listen attribute which was produced by the object
itself.
Messages that are produced by anything other than the object itself are
ignored.
Example: @amhear listener = "Wait a minute. I said the trigger word!
See also: @aahear, @ahhear, @listen.
& @amove
Command: @amove <object> = <command-list>
Attribute: Amove
Sets the action to be taken by an object whenever it moves from one
location to another, whether by using an exit, entering or leaving an
object, teleporting, or going home.
This attribute is meaningful for players, and things and will never be
automatically triggered on other object types.
Example: @amove car = @vz me=[extract(%vz,1,19)] [loc(me)]
See also: @move, @omove.
& @apay
Command: @apay <object> = <command-list>
Attribute: Apay
Sets the actions to be taken after the object is given the number of coins
specified in its Cost attribute. If the giver tries to give more than that
number of coins, the excess is refunded, and if less than the necessary
amount is given then it is all given back and a snide message is sent to
the giver.
This attribute is only meaningful for players and things, and will never be
automatically triggered on other object types.
Example: @apay Coke machine = @clone Can of Coke; :drops a can on the
floor.
See also: give, @cost, @opay, @pay.
& @asuccess
Command: @asuccess <object> = <command-list>
Attribute: Asucc
Sets the actions to be taken by an object when someone successfully picks
it up (because they passed the lock), by an exit when someone passes
through it, or when someone looks at a room and passes the room's lock.
Example: @asucc kitten = :climbs up your sleeve and nuzzles your face.
See also: @osucc, @success, SUCCESS.
& @atport
Command: @atport <object> = <command-list>
Attribute: Atport
Sets the actions to be performed by object whenever it teleports.
The actions are performed after the object moves to its new location.
This attribute is only meaningful for players and things, and will never be
automatically triggered on other object types.
Example: @atport me = &TEL.COUNT me=add(v(TEL.COUNT),1)
See also: @otport, @oxtport, @tport, @teleport.
& @aufail
Command: @aufail <object> = <command-list>
Attribute: Aufail
Sets the list of commands to be run when someone 'use's the object but
fails the object's use lock. Note that the other functions controlled
by the use lock (paying, listening, and $-commands) do not trigger
Aufail.
Example: @aufail robot = "I _told_ you to leave me alone; kill %n=100
See also: @oufail, @ufail, @use.
& @ause
Command: @ause <object> = <command-list>
Attribute: Ause
Sets the actions to be taken when someone uses the object with the use
command.
This attribute is only meaningful for players and things, and will never be
automatically triggered on other object types.
Example: @ause grenade = :EXPLODES with a thundering roar; kill %n=100;
@destroy me
See also: use, @ouse, @use.
& @away
Command: @away <object> = <message>
Attribute: Away
This attribute is sent as a message to anyone who tries to page you when
you are not connected.
This attribute is only meaningful for players, and will never be
automatically referenced on other object types.
Example: @away me = Hey, I'm not even connected. So why are you paging me?
See also: @idle, @reject, page.
& @charges
Command: @charges <object> = <count>
Attribute: Charges
This attribute allows you to limit the number of times an object can be
used. If there is a charges attribute it is decremented each time an
action on the object is triggered. Once it reaches zero, normal triggering
stops and the Runout attribute (if one is present) is run instead.
Example: @charges Fireball wand = 5
See also: @runout.
& @cost
Command: @cost <object> = <amount>
Attribute: Cost
Sets the number of coins that need to be given to an object to trigger the
Pay, Opay, and Apay attributes. If the object is given more than this
amount, the excess is returned to the giver, while if less than this amount
is given the entire amount is returned, a snide message is sent to the
giver, and the Apay, Opay, and Pay attributes are not used.
This attribute is only meaningful for things, and will never be
automatically triggered on other object types.
Example: @cost Coke machine = 25
See also: give, @apay, @opay, @pay.
& @describe
Command: @describe <object> = <description>
Attribute: Desc
Sets the description for <object>, which others see when they look at the
object. Giving all your objects, rooms, and exits good descriptions is
considered to be good building practice.
Function references and %-substitutions are allowed in descriptions, and
are evaluated when someone looks at the object. In function references,
'me' refers to the object being looked at, while %-substitutions that refer
to the enactor (such as %n, %#, %p, etc) refer to the looker.
Examples:
<object> @desc vase = You see a delicate Ming vase.
<exit> @desc elevator = There is an elevator to the east.
See also: look, @adescribe, @odescribe.
& @drop
Command: @drop <object> = <message>
Attribute: Drop
Sets the message that a player sees when he drops the object, or after he
goes through the exit.
Function references and %-substitutions are allowed in drop messages, and
are evaluated when someone drops the object. In function references,
'me' refers to the object being dropped, while %-substitutions that refer
to the enactor (such as %n, %#, %p, etc) refer to the dropper.
This attribute is only meaningful for players and things, and will never be
automatically triggered on other object types.
Examples: <object> @drop vase = You gently put down the delicate vase.
<exit> @drop elevator = The elevator doors close behind you.
See also: drop, @adrop, @odrop, DROP-TO, EXITS.
& @ealias
Command: @ealias <object> = <entrance-list>
Attribute: Ealias
Sets up a set of alternate commands that may be used as synonynms for the
command 'enter <object>' when you are in the same location as the object.
The alternate commands are separated by semicolons just like in exit names.
Entry aliases are checked for after exitnames, builtin MUSH commands, and
leave aliases for the current location, but before $-commands. If more than
one object has an entry alias that matches a player's command, the one on
the object that occurs first in the location contents list is used.
This attribute is meaningful for players and things, and will never be
automatically looked at on rooms or exits.
Example: @ealias car = get in car; car; climb in; go for a ride
See also: @lalias, enter, leave.
& @efail
Command: @efail <object> = <command-list>
Attribute: Efail
Sets the message that a player sees when he tries to enter the object but
fails because the object is not ENTER_OK or the player fails the
object's enter lock.
Function references and %-substitutions are allowed in efail messages, and
are evaluated when someone fails to enter the object. In function
references, 'me' refers to the object that the enactor tried to enter, while
%-substitutions that refer to the enactor (such as %n, %#, %p, etc) refer to
the the player who tried (and failed) to enter.
The enter lock only affects the 'enter' command and its aliases (set via
the @ealias command), it does not affect exits that lead to the object or
teleporting in.
This attribute is meaningful for players and things, and will never be
automatically triggered on rooms or exits.
Example: @efail car = The car's door is locked.
See also: @aefail, @aenter, @ealias, @enter, @oefail, @oenter, enter,
ENTER_OK.
& @enter
Command: @enter <object> = <message>
Attribute: Enter
Sets the message that a player sees when entering an object or room,
whether by using an exit, the enter or leave commands, or by teleporting.
Function references and %-substitutions are allowed in enter messages, and
are evaluated when someone enters the object. In function references,
'me' refers to the object being entered, while %-substitutions that refer
to the enactor (such as %n, %#, %p, etc) refer to the player entering the
object.
This attribute is meaningful for players, things, and rooms, and will never
be automatically triggered on exits.
Example: @enter car = You climb into the car and buckle your seatbelt.
See also: enter, @aenter, @oenter, ENTER_OK.
& @fail
Command: @fail <object> = <message>
Attribute: Fail
Sets the failure message on <object>. This message is displayed to the
player who fails to pick up the named player or thing, who fails to go
through the named exit, or who looks at a room and fails the room's lock.
Function references and %-substitutions are allowed in fail messages, and
are evaluated when someone fails to get or look at the object. In function
references, 'me' refers to the object the player tried to get or look at,
while %-substitutions that refer to the enactor (such as %n, %#, %p, etc)
refer to the player trying to get or look at the object.
This attribute is only meaningful for players and things, and will never be
automatically triggered on other object types.
Example: <object> @fail table = It's too heavy to lift!
<exit> @fail doorway = The dooknob does not turn.
See also: get, @afail, @ofail, FAILURE.
& @filter
Command: @filter <object> = <pattern>[, <pattern>...]
Attribute: Filter
This attribute specifies a series of patterns to be used to suppress
text normally forwarded by the AUDIBLE flag. If the desired pattern
contains a comma, the pattern may be enclosed in curly braces {}.
Example:
> @fo test=out
> @set #378=puppet
test> test grows ears and can now hear.
> @filter out = {* has arrived.},{* has left.}
Set.
> :has not arrived.
Wizard has not arrived.
test> From a distance, Wizard has not arrived.
> :has arrived.
Wizard has arrived.
See also: AUDIBLE, @forwardlist, @infilter, @inprefix, @prefix.
& @forwardlist
Command: @forwardlist <object> = <dbref-list>
Attribute: Forwardlist
Specifies a list of locations (specified by their db numbers) that are to
receive messages heard by <object> (filtered by the @filter attribute and
prefixed by the @prefix attribute). The messages are only forwarded if
<object> has its AUDIBLE flag set.
See also: @filter, @prefix, AUDIBLE.
& @idesc
Command: @idesc <object> = <message>
Attribute: Idesc
Sets the internal description for <object>. The internal description of an
object will be shown to any player entering it. If not set, the regular
description in the Desc attribute is shown instead.
Function references and %-substitutions are allowed in inside descriptions,
and are evaluated when someone fails to get or look at the object. In
function references, 'me' refers to the object being looked at, while
%-substitutions that refer to the enactor (such as %n, %#, %p, etc)
refer to the player doing the looking.
This attribute is only meaningful for players and things, and will never be
automatically triggered on other object types.
Example: @idesc car = You are sitting in the driver's seat of a Volkswagen
Beetle.
See also: enter, @describe, ENTER_OK.
& @idle
Command: @idle <object> = <message>
Attribute: Idle
This attribute is sent as a message to anyone who successfully pages you.
It can be used to tell someone who pages you when you will return
(if you are going to be away for a while).
This attribute is only meaningful for players, and will never be
automatically referenced on other object types.
Example: @idle me = At dinner. Back about 7PM.
See also: @away, @reject, page.
& @infilter
Command: @infilter <object> = <pattern>[, <pattern>...]
Attribute: Infilter
This attribute specifies a series of patterns to be used to suppress
text normally sent to the contents of <object> by @listen. If the desired
pattern contains a comma, the pattern may be enclosed in curly braces {}.
Example:
> @listen sports car=*
> @fo test=enter sports car
test has left.
test> Sports Car(#383Q)
> :waves.
test> Wizard waves.
Wizard waves.
> @infilter sports = *waves*
> :waves.
Wizard waves.
> :knocks on the window.
test> Wizard knocks on the window.
Wizard knocks on the window.
See also: @filter, @inprefix, @listen, @prefix.
& @inprefix
Command: @inprefix <object> = <prefix text>
Attribute: Inprefix
This attribute, when set, will prefix all text that is sent to the contents
of <object> by @listen. The default is to have no prefix, the text is
forwarded unadorned.
Example:
> @listen sports car=*
> @fo test=enter sports car
test has left.
test> Sports Car(#383Q)
> :waves.
test> Wizard waves.
Wizard waves.
> @inprefix sports car = In the mundane world outside,
test> In the mundane world outside, Wizard waves some more.
Wizard waves some more.
See also: @filter, @infilter, @listen, @prefix.
& @kill
Command: @kill <object> = <message>
Attribute: Kill
This command sets the message that is shown to anyone who kills <object>.
This attribute is only meaningful for players and things, and will never be
automatically triggered on other object types.
Function references and %-substitutions are allowed in kill messages, and
are evaluated when someone kills the object. In function references, 'me'
refers to the object that was killed, while %-substitutions that refer to
the enactor (such as %n, %#, %p, etc) refer to the player doing the killing.
Example: @kill guard = The guard says "I'll get.. you... for... this... %n"
as he falls down and dies.
See also: kill, @akill, @okill, BEING KILLED, IMMORTAL, WIZARD.
& @Lalias
Command: Lalias <object> = <entrance-list>
Attribute: Lalias
Sets up a set of alternate commands that may be used as synonynms for the
command 'leave' when you are inside a player or a thing. The alternate
commands are separated by semicolons just like in exit names.
Leave aliases are checked for after exitnames and builtin MUSH commands, but
before enter aliases and $-commands.
This attribute is meaningful for players and things, and will never be
automatically looked at on rooms or exits.
Example: @ealias car = get in car;car;climb in
See also: @ealias, enter, leave.
& @leave
Command: @leave <object> = <message>
Attribute: Leave
Sets the message that a player sees when leaving an object or room, whether
by using an exit, the enter or leave commands, or by teleporting.
Function references and %-substitutions are allowed in leave messages, and
are evaluated when someone leaves the object. In function references,
'me' refers to the object being left, while %-substitutions that refer
to the enactor (such as %n, %#, %p, etc) refer to the player leaving the
object.
This attribute is meaningful for players, things, and rooms, and will never
be automatically triggered on exits.
Example: @leave car = You unbuckle your seatbelt and climb out of the car.
See also: leave, @aleave, @oleave.
& @lfail
Command: @lfail <object> = <command-list>
Attribute: Lfail
Sets the message that a player sees when he tries to leave it but fails
because the player fails the object's leave lock.
The leave lock only affects the 'leave' command and its aliases (set via
the @ealias command), it does not affect going home, using an exit in the
location, or teleporting out.
This attribute is meaningful for players and things, and will never be
automatically triggered on rooms or exits.
Example: @lfail plane = You don't have a parachute!
See also: @aleave, @alfail, @lalias, @leave, @oleave, @olfail, leave.
& @listen
Command: @listen <object> = <string>
Attribute: Listen
This attribute contains a wildcard pattern that the object listens for.
Anything spoken, posed, emitted, or whispered in the room that <object> is
in, as well as messages resulting from using objects (such as Opay and Succ
messages) are checked against the Listen attribute. When the object hears
something that matches the pattern, it triggers the Ahear attribute, as
well as either the Amhear or Aahear attributes, as appropriate,
substituting %0 the string that matched the first wildcard character in the
Listen, %1 for the second. etc. If the pattern in the Listen attribute is
matched, objects in <object>'s inventory will also hear the message and
have a chance to match it. Objects whose Listen attribute is set to
anything will be listed when a @sweep command is run by someone in the
same room.
If the @listen pattern is matched, then the object's contents will
hear the message also, prefixed by the text in @inprefix if it is set. Any
text that matches any pattern specified in @infilter will not be sent to
the contents.
Example: @listen camera = * has arrived.
@ahear camera = @va me = %va %0
See also: @aahear, @ahear, @amhear, @sweep, @inprefix, @infilter.
& @move
Command: @move <object> = <command-list>
Attribute: Move
Sets the message that an object sees after it moves from one location to
another, whether by using an exit, entering or leaving an object,
teleporting, or going home.
This attribute is meaningful for players, and things and will never be
automatically triggered on other object types.
Example: @move bopper = OK. You're there now.
See also: @amove, @omove.
& @odescribe
Command: @odescribe <object> = <message>
Attribute: Odesc
Sets the message (prefixed by the player's name) that is shown to others in
the room when someone looks at <object>.
Example: @odesc vase = carefully inspects the vase.
See also: look, @adescribe, @describe, @idesc.
& @odrop
Command: @odrop <object> = <message>
Attribute: Odrop
Sets the message (prefixed by the player's name) that is shown to others in
the room when someone drops <object>, or to others in the room that the
player arrives in after taking an exit.
Example: <object> @odrop loadstone = puts down the loadstone and then
wipes sweat from %p brow.
<exit> @odrop elevator = enters the elevator from the lobby.
See also: drop, @adrop, @drop, DROP-TO, EXITS.
& @oefail
Command: @oefail <object> = <command-list>
Attribute: Oefail
Sets the message (prefixed by the player's name) that is shown to others in
the same room as the player when he tries to enter the object but fails
because the object is not ENTER_OK or the player fails the
object's enter lock.
The enter lock only affects the 'enter' command and its aliases (set via
the @ealias command), it does not affect exits that lead to the object or
teleporting in.
This attribute is meaningful for players and things, and will never be
automatically triggered on rooms or exits.
Example: @oefail car = tries to open the car's door, but it is locked.
See also: @aefail, @aenter, @ealias, @efail, @enter, @oenter, enter,
ENTER_OK.
& @oenter
Command: @oenter <object> = <message>
Attribute: Oenter
Sets the message (prefixed by the player's name) that is shown to others in
the location being entered when someone enters <object>. Note that the
message is shown to those inside the object, not those outside.
This attribute is meaningful for players, things, and rooms, and will never
be automatically triggered on exits.
Example: @oxenter wormhole = enters the wormhole from normal space.
See also: enter, @aenter, @enter, @oxenter.
& @ofail
Command: @ofail <object> = <message>
Attribute: Ofail
Sets the message (prefixed by the player's name) that is shown to others in
the room when someone fails to pick up the named player or thing, fails to
go through the named exit, or looks at the room and fails the room's lock.
Example: <object> @ofail table = tries to pick up the table, but it is too
heavy.
<exit> @ofail doorway = tries the knob on the door, to no avail.
See also: get, look, @afail, @fail, FAILURE.
& @okill
Command: @okill <object> = <message>
Attribute: Okill
Sets the message (prefixed by the player's name) that is shown to others in
the room when someone kills <object>.
This attribute is meaningful for players, things, and rooms, and will never
be automatically triggered on exits.
Example: @okill guard = bashes in the guard's skull, killing him.
See also: kill, @akill, @kill, BEING KILLED, IMMORTAL, WIZARD.
& @oleave
Command: @oleave <object> = <message>
Attribute: Oleave
Sets the message (prefixed by the player's name) that is shown to others in
the location being left when someone leaves <object>. Note that the
message is shown to those inside the object, not those outside.
This attribute is meaningful for players, things, and rooms, and will never
be automatically triggered on exits.
Example: @oleave wormhole = departs the wormhole to return to normal space.
See also: leave, @aleave, @leave, @oxleave.
& @olfail
Command: @olfail <object> = <command-list>
Attribute: Olfail
Sets the message (prefixed by the player's name) that is shown to others in
the same room as the player when he tries to leave it but fails because the
player fails the object's leave lock.
The leave lock only affects the 'leave' command and its aliases (set via
the @ealias command), it does not affect going home, using an exit in the
location, or teleporting out.
This attribute is meaningful for players and things, and will never be
automatically triggered on rooms or exits.
Example: @olfail plane = thinks about jumping out of the plane without a
parachute, but wisely reconsiders.
See also: @aleave, @alfail, @lalias, @leave, @lfail, @oleave, leave.
& @omove
Command: @omove <object> = <command-list>
Attribute: Move
Sets the message that others in the same location see after the object has
moved to that location from somewhere else, whether by using an exit,
entering or leaving an object, teleporting, or going home.
This attribute is meaningful for players, and things and will never be
automatically triggered on other object types.
Example: @omove car = coasts to a stop.
See also: @amove, @move.
& @opay
@opay <object> = <message>
Attribute: Opay
Sets the message (prefixed by the player's name) that is shown to others in
the room when someone pays <object> enough to satisfy its Cost attribute.
This attribute is only meaningful for players and things, and will never be
automatically triggered on other object types.
Example: @opay Coke machine = slips some change into the coin slot on the
Coke machine. You hear some rumbling from
inside the machine and a can of Coke appears
in the tray at the bottom of the machine.
See also: give, @cost, @apay, @pay.
& @osuccess
Command: @osuccess <object> = <message>]
Attribute: Osucc
Sets the message (prefixed by the player's name) that is shown to others in
the room when someone picks up the named player or thing, goes through the
named exit, or looks at the room and passes the room's lock.
Setting Osuccess messages on all takeable objects and usable exits is
considered good building practice.
Examples: <object> @osucc vase = carefully picks up the vase.
<exit> @osucc doorway = opens the door and leaves the room.
The door closes behind %o with a click.
See also: get, look, @asuccess, @success, SUCCESS.
& @otport
Command: @otport <object> = <message>
Attribute: Otport
Sets the message (prefixed by your name) that others in the room to which
the object goes see when the object teleports there.
This attribute is only meaningful for players and things, and will never be
automatically triggered on other object types.
Example: @otport me = appears in a flash of non-wizardly brilliance.
See also: @atport, @oxtport, @tport, @teleport.
& @oufail
Command: @oufail <object> = <message>
Attribute: Oufail
Sets the message that others in the same room see when someone tries to
use object but fails the object's use lock. Note that the other functions
controlled by the use lock (paying, listening, and $-commands) do not
trigger Oufail.
Example: @oufail robot = tries to activate the robot, but to no avail.
See also: @aufail, @ufail, @use.
& @ouse
Command: @ouse <object> = <message>
Attribute: Ouse
Sets the message (prefixed by the player's name) that is shown to others in
the room when someone uses <object>.
This attribute is only meaningful for players and things, and will never be
automatically triggered on other object types.
Example: @ouse camera = takes a picture with the camera.
See also: use, @ause, @use.
& @oxenter
Command: @oxenter <object> = <message>
Attribute: Oxenter
Sets the message (prefixed by the player's name) that is shown to others in
the location being left when someone enters <object>. Note that the
message is shown to those outside the object, not those inside.
This attribute is meaningful for players, things, and rooms, and will never
be automatically triggered on exits.
Example: @oxenter wormhole = climbs into the wormhole and vanishes.
See also: enter, @aenter, @enter, @oenter.
& @oxleave
Command: @oxleave <object> = <message>
Attribute: Oxleave
Sets the message (prefixed by the player's name) that is shown to others in
the location being entered when someone leaves <object>. Note that the
message is shown to those outside the object, not those inside.
This attribute is meaningful for players, things, and rooms, and will never
be automatically triggered on exits.
Example: @oxleave wormhole = steps out of a hyperspatial wormhole.
See also: leave, @aleave, @leave, @oleave.
& @oxtport
Command: @oxtport <object> = <message>
Attribute: Oxtport
Sets the message (prefixed by your name) that others in the room from which
the object comes see when the object teleports out.
This attribute is only meaningful for players and things, and will never be
automatically triggered on other object types.
Example: @oxtport me = disappears in a flash of non-wizardly brilliance.
See also: @atport, @otport, @tport, @teleport.
& @pay
Command: @pay <object> = <message>
Attribute: Pay
Sets the message that is shown to the player who gives <object> enough
money to satisfy its Cost attribute.
This attribute is only meaningful for things, and will never be
automatically triggered on other object types.
Example: @pay Coke machine = You slip some change into the slot.
See also: give, @apay, @cost, @opay.
& @prefix
Command: @prefix <object> = <prefix text>
Attribute: Prefix
This attribute, when set, will be used as a prefix for all text forwarded
by the 'audible' flag on an object or exit. The default if this attribute
is not set is 'From <object name>,' for objects, and 'From a distance,'
for exits.
Example:
> @fo test=out
> @set #378=puppet
test> test grows ears and can now hear.
> :does something silly.
Wizard does something silly.
test> From a distance, Wizard does something silly.
> @prefix out=From some strange place
Set.
> :does something even sillier.
Wizard does something even sillier.
test> From some strange place Wizard does something even sillier.
See also: AUDIBLE, @filter, @forwardlist, @infilter, @inprefix.
& @reject
Command: @reject <object> = <message>
Attribute: Reject
This attribute is sent as a message to anyone who tries to page you but
you have prevented them from paging you via your page lock (@lock/page).
This attribute is only meaningful for players, and will never be
automatically referenced on other object types.
Example: @reject me = I _told_ you not to page me anymore...
See also: @away, @idle, page.
& @runout
Command: @runout <object> = <command list>
Attribute: Runout
Sets the actions to be taken by <object> when another of its attributes is
triggered (either automatically or via the @trigger command) and its
Charges attribute is zero. When this occurs, the Runout attribute is run
INSTEAD OF the attribute that would have run normally.
Example: @runout magic wand = :fizzles and turns to dust.; @destroy me
See also: @charges.
& @sex
Command: @sex <object> = <gender>
Attribute: Sex
Sets the gender for <object>, which is used to determine which pronouns to
use when replacing %p, %o, and %s parameters in messages that apply to
<object>. Genders that start with M or m are considered male, those
starting with F, f, W, or w are considered female, and anything else is
considered neuter.
Example: @sex me = female
@sex me = No thank you (Silly, but possible. Treated as neuter)
See also: GENDER.
& @startup
Command: @startup <object> = <command list>
Attribute: Startup
Sets a list of commands to be performed by <object> when the game is
started up. Typical actions include going home, cleaning visitors out of
a room, resetting a puzzle or complex object to its initial state, or
starting up an object that wants to run continuously.
Example: @startup me = @vz me=MUSH was last restarted at [time()].
@startup me = home
& @success
Command: @success <object> = <message>
Attribute: Succ
Sets the message that is shown to the player who successfully picks up the
named player or thing, goes through the named exit, or looks at the room
and passes the room's lock.
Example: <object> @succ vase = You carefully pick up the delicate vase.
<exit> @succ doorway = You open the door and walk through the
doorway.
See also: get, look, @asuccess, @osuccess, SUCCESS.
& @tport
Command: @tport <object> = <message>
Attribute: Tport
Sets the message that an object sees whenever it teleports.
The message is displayed after the object moves to its new location.
This attribute is only meaningful for players and things, and will never be
automatically triggered on other object types.
Example: @tport me = Hey! I teleported. Wow!
See also: @atport, @otport, @oxtport, @teleport.
& @ufail
Command: @ufail <object> = <message>
Attribute: Ufail
Sets the message that someone sees when they try to use object but fail
the object's use lock. Note that the other functions controlled by the use
lock (paying, listening, and $-commands) do not trigger Oufail.
Example: @ufail robot = The robot pointedly ignores you.
See also: @aufail, @oufail, @use.
& @use
Command: @use <object> = <message>
Attribute: Use
Sets the message that is shown to the player who uses <object>.
This attribute is only meaningful for players and things, and will never
be automatically triggered on other object types.
Example: @use camera = You take a picture with the camera. Click.
See also: use, @ause, @ouse.
& ABODE
ABODE If a room is set ABODE, players can set their homes there,
and can set the homes of objects there. It does not mean that a
player can open an exit to that room, only that they can set their
home there.
& AUDIBLE
Flag: AUDIBLE(a) (all types)
This flag may be set on an object or exit. When set on an object,
everything from a say, pose, or emit inside the object will be sent to
every object in the location of that object as well as to all objects
mentioned in the object's Forwardlist attribute. When set on an exit,
everything from a say, pose, or emit in the room the exit is in will be
forwarded to the room the exit points to. In both cases the @prefix
attribute will be inserted in front of the text, or a default prefix if no
@prefix attribute is set. If the @filter attribute is present, it will be
used to suppress those messages matching any of the patterns specified.
Setting the audible flag on a room has no effect.
See also: @filter, @forwardlist, @prefix.
& CHOWN_OK
CHOWN_OK This flag, when set, allows you to transfer ownership to
another player. To set it, you must be carrying the object. You
also have to be in the room if you want to set this flag on rooms
or exits. After this flag is set, the new player may gain
ownership of the object by using the @chown command (See @chown).
& CONNECTED
CONNECTED This flag applies only to players and it shows if the
player is connected or not. Thus, each time you are connected to
the game, you should see the 'c' flag set, otherwise, you are DEAD!
You cannot reset this flag, and it is used internally by the code
for things like tabulating players for the WHO list, etc.
& DARK
DARK If a room is DARK, then no items are shown when a person
'looks' there. If a thing is DARK, then "look" does not list that
object in the room's Contents:, and if an exit is DARK, it doesn't
show up in the Obvious Exits: list. Puppets and objects that can
listen cannot be DARK.
& DESTROY_OK
DESTROY_OK When set on an object, it allows any player to destroy
it as long as the object is not locked against them. This is good
for things like notes, whereby the recipient can destroy the note
after reading it, instead of having to look for you to destroy it.
& ENTER_OK
ENTER_OK If an object or person is ENTER_OK, other players may
enter the object or person by using 'enter <object/person>. Players
must also have the ENTER_OK set if they wish to be able to recieve
things given to them by other players via the
'give <player> = <object>'.
& GOING
GOING Used internally for the @destroy command, it is set on
rooms that are set to be destroyed. In the event that a player
decides they don't want to destroy the room after all then they can
unset it.
& HAVEN
HAVEN @set here=haven;@set me=haven. If a room is HAVEN, you
cannot kill in that room. If a player is set HAVEN, he cannot be
paged. Bummer.
& KEY
KEY When set on an object prevents puppets from picking it up.
& LINK_OK
LINK_OK If a room is LINK_OK, anyone can link exits to it (but
still not from it). It has no meaning for people, things, or exits.
See @link.
& UNFINDABLE
If a player is set UNFINDABLE, he cannot be found by the @whereis
command or by the loc() or room() functions. Bummer.
& FLOATING
If a room is set floating, you will not be notified every 10
minutes or so that you have a disconnected room.
& OPAQUE
OPAQUE When set on a player, it prevents other players from
seeing what you are carrying in your inventory. Only exception is
when the object you are carrying belongs to the other player
looking at you.
& PLAYER
PLAYER The PLAYER flag identifies you as a player. This flag cannot
be reset by any player, not even a Wizard (not, yet, anyway
*grin*). It is used mainly by the mush code to identify your
commands, check for validity of commands or locks etc. Generally,
just pretend it isn't even there.
& JUMP_OK
When a room is set JUMP_OK, then that room can be teleported into
by anyone. See @teleport.
& PUPPET
PUPPET @set <object> = puppet. Causes an object to grow eyes and
ears, and relay all it sees and hears to its owner.
See: @force, PUPPETS
& ROOM
ROOM This flag is automatically set on rooms when you @dig a new
room. It cannot be changed. Rooms have the added advantage that
they can be saved from destruction by setting the room to !GOING
(SEE GOING).
However, this can only be done if no other room/object was created
that overwrote your room when it was set for destruction.
& VISUAL
VISUAL The flag a lot of players have been waiting for. When set on
your object, it allows other players to examine it and see all the
object's attributes as if they owned the object. They cannot make
any changes to the object. This was previously called SEE_OK in
some MUSHes.
& QUIET
QUIET This flag when set on yourself prevents you from hearing
the 'set' or 'triggered' messages from any objects you own. When
set on an object, only that object will not relay its messages.
& HALTED
HALTED While this flag is set, the object cannot perform any mush
actions, listen, be triggered, etc.
& GAGGED
GAGGED When set on a player, it disables him from doing anything
except moving and looking. He cannot talk, page, build, pose, get
or drop objects. (Yet another consequence of annoying the wizards.)
Only wizards can set this flag.
& STICKY
STICKY If a thing is STICKY, it goes home when dropped
(See HOMES). If a room is STICKY, its drop-to is delayed until the
last person leaves (See DROP-TOs). Only meaningful for things and
rooms.
& TEMPLE
TEMPLE If a room is TEMPLE, you can sacrifice things for money by
dropping them there. It has no meaning for players, things, or
exits. Only wizards can set this flag.
& BUILDER
BUILDER If a player has the BUILDER flag set, it means that all the
building commands will work for them. Without it, you can only
explore the world but not add to it. This is only settable by
Wizards. Not all MUSHes use the BUILDER flag. Some allow all players
to build.
& WIZARD
WIZARD If a person is WIZARD, they are a wizard, unkillable,
subject to fewer restrictions, and able to use wizard commands.
In general, WIZARDs can do anything using #<number> or *<player>.
Only player #1 can set and unset the WIZARD flag of other players.
No WIZARD can turn their own WIZARD flag off.
& IMMORTAL
IMMORTAL Objects set immortal cannot be killed and don't use up money.
Only settable by wizards. This is useful when an object's location
shouldn't be changed by Joe Player, but you don't want to have to relink it
to its current location whenever it moves.
& VERBOSE
VERBOSE This flag causes all commands executed by the object having
the flag to be sent to the owner of the object. i.e.:
@create foo
@set foo=VERBOSE
@force foo="Hi.
foo] "Hi.
foo says "Hi."
& INHERIT
INHERIT Previously, Wizard-owned objects had wizard powers. This was
a problem in many cases, so that behavior has changed. Now, only Wizard
objects or Wizard-owned Inherit-set objects have wizard powers. Only
players can set the Inherit flag, and the Inherit flag is reset during
@chown. If a player is set Inherit, all his stuff is assumed to be
inherit, so his objects can control him. If a player is NOT Inherit,
his stuff does NOT control him. (i.e. cannot @force him.) This flag
is not especially useful for non-wizards.
& NOSPOOF
Flag: NOSPOOF(N) (all types)
This flag gives you mucho output when people @emit. It can be annoying,
but you'll know who's spoofing.
See also: @emit, @femit, @oemit, @pemit.
& SLAVE
Flag: SLAVE(s) (players)
If set on a player, neither the player nor any of his objects may perform
any commands that change the database. Some sites may restrict additional
commands. This flag may only be set or cleared by wizards.
& SAFE
Flag: SAFE(s) (exits, things, rooms)
When set, requires the use of the /override switch to @destroy in order to
destroy the object. It does not prevent the destruction of the object,
but merely requires some additional effort.
See also: @destroy.
& MONITOR
Flag: MONITOR(M) (all types)
When set, anytime the object hears something from someone who passes the
object's use lock, the object's attributes are scanned for attributes
of the form '^<pattern>:<commandlist>'. If the message matches the
wildcarded <pattern>, then <commandlist> is executed, substituting %0 for
the text that matched the first wildcard, %1 for the second, and so on.
All matching attributes are executed, not just the first.
See also: LISTENING.
& ROBOT
Flag: ROBOT(r) (players, exits, things)
If set on a player, indicates that the player is a robot and is allowed to
use the OUTPUTPREFIX and OUTPUTSUFFIX commands that many publicly available
robot programs require. Some MUSHes do not restrict access to the
OUTPUTPREFIX and OUTPUTSUFFIX commands.
If set on an exit or a thing, indicates that robot players may not use the
exit or pick up the thing, the player is treated as having failed the lock.
See also: OUTPUTPREFIX, OUTPUTSUFFIX, @robot.
& TRANSPARENT
Flag: TRANSPARENT(t) (exits)
If an exit is TRANSPARENT, then when you look at it you see the description
of the room on the other side of the exit in addition to the description
of the exit.
& ARBITRARY COMMANDS
Topic: ARBITRARY COMMANDS
You may define commands that are triggered whenever someone enters a command
that matches the command template (wildcarding allowed). These commands
are called arbitrary commands, user-defined commands, or $-commands (for how
they are defined), and they are checked for only after the check for
single-character commands, exits, and internal commands have been performed
and have failed (so an arbitrary command that matches 'page *' will never
be performed).
You define an arbitrary command by storing a string of the form
'$<template>:<commandlist>' in an attribute of an object, then the command
will be available to anyone who carries the object, is in the same room as
the object, or is inside the object. Only use user-named attributes and
VA-VZ for arbitrary commands, as many of the predefined attributes are not
for arbitrary commands. <template> is the pattern to check for (it may
contain wildcards), and <commandlist> is a semicolon-separated list of
commands to perform. The text that the wildcard characters matched are
available in the variables %0 through %9.
{ 'help arbitrary2' for more }
& arbitrary2
Example:
> @va testobj = $foobar *:"I was foobar'ed with %0.
Set.
> foobar xyzzy
testobj says "I was foobar'ed with xyzzy"
You can prevent individual attributes from being checked for $-commands
with the command '@set <obj>/<attr> = no_program'. Attributes so set
are reported with ($) following the attribute name when examined.
The command '@set <obj>/<attr> = !no_program' clears the flag.
The following attributes are never checked for $-commands: ALIAS CHARGES
DESC DROP FAIL IDESC ODESC ODROP OFAIL OSUCC SEX SUCC.
See also: @set.
& ATTRIBUTE OWNERSHIP
Topic: ATTRIBUTE OWNERSHIP
The attributes on an object may be owned indepently from the object.
Normally, the owner of the object owns all of its attributes.
In addition to an owner, each attribute also has a locked flag,
set or cleared with @lock <obj>/<attr> and @unlock <obj>/<attr>.
This flag controls whether or not the owner of the object may
@chown the attribute to himself with @chown <object>/<attrib>,
as well as whether or not the attribute is automatically @chowned to
the new owner when the object is @chowned.
You may lock and unlock attributes that you own on any object (whether
you own the object or not), and you may @chown an attribute that you own
to the owner of the object if it is unlocked. The examine command
will show you all attributes that you own on an object, even if you
don't own the object.
Locked attributes may not be modified or removed, and do not change ownership
when the object containing them is @chowned.
{ 'help attrib2' for more }
& attrib2
You may not modify or remove attributes that you own that are stored
on objects that you do not own, but you may modify or remove attributes
owned by others on your objects (if you do this, the attribute becomes owned
by you).
If an attribute is owned by someone other than the object's owner, then
the number of the attribute's owner is shown in parentheses immediately
after the attribute name. A + within the parentheses following the owner
number (if present) means that the attribute is locked (which means that
it will not change ownership of the object is @chowned), while a $ within
the parentheses means that $-commands are not checked for that attribute.
When checking an attribute lock against an object, the lock will always
fail if the locked object is not owned by the same player as the attribute
being tested. The comparison specified in the lock is only performed if
the owner of the locked object also owns the attribute on the object
being checked.
See also: @chown, @lock, @set, @unlock, examine.
& BEING KILLED
Topic: BEING KILLED
Getting killed is no big deal. If you are killed, you return to your home,
and all things you carry return to their homes. You also collect 50 coins
in insurance money (unless you have >= 10000 coins or you were killed via
the Wizard slay command). Generally, killing is not encouraged unless
absolutely necessary. (Note: Killing a wizard is a quick way to discover
the many uses of the @boot command... and killing anyone can be very
rude.)
See also: kill, @akill, @kill, @okill, IMMORTAL, WIZARD.
& BOGUS COMMANDS
Topic: BOGUS COMMANDS
Bogus commands can be made using exits. For example, to make a 'sit'
command, one could "@open sit", then "@link sit=here" (because unlinked
exits can be stolen), "@lock sit=#0" (impossible for a room to pass a lock,
#0 is always a room, therefore the lock always fails), and "@fail sit=You
sit on the chair."; "@ofail sit=sits on the chair.". Since nobody can go
through it, it always fails. The @fail message is displayed to the player,
and the @ofail message (preceded by the player's name) to everyone else.
See also: @afail, @fail, @link, @lock, @ofail, @open.
& BOOLEAN VALUES
Topic: BOOLEAN VALUES
Boolean values are internally considered to be either 1, generally
interpreted as being true, and 0, which is generally interpreted as being
false. Now, any string is interpreted as true(1), except for the null
string (whose length is 0), which is false(0). A #-1 is interpreted as
false(0), and any other #<dbref> is interpreted as true(1). Any number
except 0 is interpreted as true(1), except 0 which is false(0). (Yes, even
negative numbers are true(1))
Examples:
not(foo) = 0 not(<null string>) = 1 not(-66) = 0
not(0) = 1 not(#-1) = 1 not(#12) = 0
And so on...
Note: These rules only apply when a function expects a Boolean
value, not for strings that expect other values.
& CONTROL
Topic: CONTROL
There are 5 rules to controlling objects:
1) You control anything you own.
2) Anything you own that has its INHERIT flag set controls anything you
own (including you).
3) Anything you own that does not have its INHERIT flag set only controls
other things that you own that do not have their INHERIT flag set and
do not control you, unless YOU have your inherit flag set.
4) A wizard controls everything.
5) Anybody controls an unlinked exit, even if it is locked.
Builders should beware of 5, lest their exits be linked or stolen.
Most of the commands for altering the database and many commands and
functions that retrieve information only work on objects that you control.
& COSTS
Topic: COSTS
Certain commands cost money to use, they will fail if you don't have
enough. Use the @list costs command to find out what these commands are
and how much they cost.
See also: @list.
& CREDITS
Topic: CREDITS
TinyMUSH 2.0 is derived from Larry Foard's TinyMUSH (which was itself derived
from TinyMUD, written by Jim Aspnes). Ideas for features (and occasionally
code) came from many places, including TinyMUSE, PernMUSH, and TinyTIM.
We would like to thank the following people:
- Jim Aspnes, for the original TinyMUD (from which TinyMUSH was derived)
- Larry Foard, for the original implementation of TinyMUSH.
- Marcus Ranum for the original Untermud database layer code, and Andrew
Molitor for getting it to work with TinyMUSH.
- Andrew Molitor (again) for the VMS port.
- Russ(Random) and Jennifer(Moira) Smith, for ideas, comments, and coding
help.
- R'nice(TinyTIM) for more good ideas than we could shake a wand of coding
at. (@doing, @edit enhancements, a REAL use command, lotsa minor fixes
and tweaks)
{ 'help credits2' for more }
& credits2
Topic: CREDITS (continued)
- Coyote(TinyTIM, DungeonMUSH, NarniaMUSH), for finding some nasty bugs and
NOT using them for evil purposes.
- Ambar, Amberyl, Sh'dow, Jellan, and Miritha (all from PernMUSH) for
numerous bug fixes, enhancements, and ideas.
- Hcobb(TinyTIM) and Furie(DungeonMUSH) for inspiring the parser rewrite and
other security-related fixes and enhancements.
- The many other people who have contributed ideas, comments, or complaints
about bugs.
& DROP-TOS
Topic: DROP-TOS
When the @link command is used on a room, it sets a drop-to location. Any
object dropped in the room (if it isn't STICKY) will go to that location.
If the room is STICKY, the drop-to will be delayed until the last person in
the room has left.
See also: @link, STICKY.
& ENACTOR
Topic: ENACTOR
The enactor is the object that caused an action list to be performed.
So, the enactor of the Ahear action list is the player or object who
said/emoted/etc the message that matched the Listen attribute, the
enactor of the Apay attribute is the player who gave the object money, etc.
The enactor of an attribute that is run by a @trigger command is the
object that ran the @trigger command. The following substitutions can be
performed in an action list to return information about the enactor:
%# or [v(#)] - Database number of the enactor
%N/%n or [v(N)]/[v(n)] - Name of the enactor.
%O/%o ... - Objective pronoun for the enactor (him her it)
%P/%p ... - Possessive pronoun for the enactor (his her its)
%S/%s ... - Subjective pronoun for the enactor (he she it)
See also: SUBSTITUTION.
& MOVING
Topic: MOVING
A number of things happen when you leave one location and enter another
(assuming you pass the lock on the exit or have permission to enter the
object or to teleport to the location). The following list describes the
actions that MUSH takes when an object moves from one place to another.
Note that if an indicated attribute is not set, no message is displayed
(or no action is performed).
- If you are using an exit (as opposed to teleporting, entering an object,
or going home), You receive the SUCC message for the exit, others in the
old location receive the exit's OSUCC message, and the exit runs its
ASUCC action list.
- If you are teleporting or being teleported, others in the old location
receive your OXTPORT attribute.
- If you are a player or have your LISTEN attribute set to something,
and if the old location is not dark and you are not dark, you receive the
LEAVE message for the old location, others in the old location receive
the OLEAVE message, and the old location runs its ALEAVE action list.
Others in the new location receive the OXENTER message from the old
location, and others in the old location receive the message '<yourname>
has left.'
{ 'help moving2' for more }
& moving2
- You are moved to the new location. If you are entering an object,
teleporting, or going home, all KEY objects are stripped from you.
- If the new location is a room, you receive the room's DESC, others in the
room receive the ODESC, and the room runs its ADESC. If you pass the
room's lock do the same with SUCC, OSUCC, and ASUCC, otherwise use FAIL,
OFAIL, and AFAIL.
- If the new location is a player or an object, you receive the location's
IDESC (or DESC if the IDESC is not set). In either event, others in the
same location see the ODESC message and the location runs its ADESC
action list.
- You are shown the contents and visible exits if the location is not DARK.
- If you used an exit, then you receive the DROP message for the exit,
others in the new room receive the exit's ODROP message, and the exit
runs its ADROP action list.
- If you are teleporting or being teleported, you receive your TPORT
attribute, others in your new location receive your OTPORT attribute,
and your ATPORT attribute is run.
- You receive your MOVE attribute, others in your new location receive
your OMOVE attribute, and your AMOVE attribute is run.
{ 'help moving3' for more }
& moving3
- If you are a player, or have your LISTEN attribute set to something,
and if the old location is not dark and you are not dark, you receive the
ENTER message for the new room, others in the new room receive the OENTER
message, and the new room runs its AENTER action list. Others in the room
you just left receive the new room's OXLEAVE message, and others in the
old location receive the message '<yourname> has arrived.'
- If the old location is a STICKY room and has its drop-to set, see if
objects in that room should be sent to the drop-to location. If so,
do it.
- If you are a player, you have a chance of finding some money.
See also: @adesc, @adrop, @aenter, @afail, @aleave, @asucc, @atport, @desc,
@drop, @enter, @fail, @leave, @listen, @odesc, @odrop, @oenter,
@ofail, @oleave, @osucc, @oxenter, @oxleave, @oxtport, @succ,
@tport, move, @teleport, home, KEY, STICKY, DROP-TOS, FAILURE,
SUCCESS.
& EXITS
Topic: EXITS
An exit links one location to another location, providing a way to travel
on the MUSH. Although normally used to link rooms together, exits can be
made to and from players and objects.
You may pick up exits that you own, and drop exits into locations that
you own. When you pick up or drop an exit, anyone in the exit's new
location may use the exit and travel to its destination.
If an exit is set DARK it will not show up in the list of obvious exits in
a room.
See also: @link, @open.
& FAILURE
Topic: FAILURE
You fail to use a player or a thing when you cannot take it (because it's
lock fails). You fail to use an exit when you cannot go through it
(because it is unlinked or locked). You fail to use a room when you fail
to look around (because it's locked).
See also: get, look, @afail, @fail, @lock, @ofail, STRINGS.
& FLAGS
Topic: FLAGS
Everything in the universe of this MUSH (Rooms, Exits, Things, Players,
etc) are represented in the same way at the program level. A room merely
has the room flag set and a player has the player flag set. In addition,
flags also give objects abilities or qualities. For instance, a wizard
has the wizard flag set. That is what lets the program know he may use
wizard abilities. An object or room may have the dark flag set. In the
case of an object, this makes the object invisible to normal eye-sight.
In the case of a room, the room becomes too dark to see other objects or
players. To get a list of the flags that are available, type '@list flags'
or 'help flag list'. For more specific information on a particular flag,
request help on the flag's name, as in 'help ENTER_OK'.
& FLAG LIST
Topic: FLAG LIST
Flag Title Flag Title Flag Title Flag Title
-------------------------------------------------------------------------
A - ABODE B - BUILDER C - CHOWN_OK D - DARK
E - EXIT F - FLOATING G - GOING H - HAVEN
I - INHERIT J - JUMP_OK K - KEY L - LINK_OK
N - NOSPOOF O - OPAQUE P - PLAYER Q - QUIET
M - MONITOR R - ROOM S - STICKY T - TEMPLE
U - UNFINDABLE V - VISUAL W - WIZARD c - CONNECTED
d - DESTROY_OK e - ENTER_OK g - GAGGED h - HALTED
i - IMMORTAL p - PUPPET r - ROBOT s - SLAVE or SAFE
t - TRANSPARENT v - VERBOSE
For information on a particular flag, type 'help <flagname>'.
& FUNCTIONS
Topic: FUNCTIONS
Functions are specialized commands used to manipulate strings and other
input. The format for a function is of this form: [fun-name(<input>)]
Although usually the []'s indicate an input that is optional, in this case
they are necessary and tell the MUSH that this is a function, although
nested functions (like [first(rest(This is a nice day))] returns 'is') do
not require more than one pair of []'s. Nested brackets may be used when
it is necessary to insert a function call in the middle of an argument,
like [get(me/[get(me/vz)])], which returns the contents of the attribute
named in the VZ attribute.
See also: FUNCTION LIST
& FUNCTION LIST
Topic: FUNCTION LIST
The following functions are available:
ABS() ADD() AFTER() AND() BEFORE() CAPSTR()
CAT() COMP() CON() DELETE() DIST2D() DIST3D()
DIV() EDIT() ELOCK() EQ() ESCAPE() EXIT()
EXTRACT() FIRST() FLAGS() GET() GET_EVAL() GT()
GTE() HASFLAG() HOME() ITER() LATTR() LCON()
LCSTR() LEXITS() LOCATE() LNUM() LOC() LOCK()
LT() LTE() LWHO() MATCH() MAX() MEMBER()
MID() MIN() MOD() MONEY() MUDNAME() MUL()
NAME() NEARBY() NEQ() NEXT() NOT() NUM()
OBJ() OR() OWNER() PARENT() POS() POSS()
RAND() REMOVE() REST() REVERSE() REVWORDS() ROOM()
S() SEARCH() SECS() SECURE() SIGN() SPACE()
STARTTIME() STATS() STRLEN() SUB() SUBJ() SWITCH()
TIME() TYPE() U() UCSTR() V() VERSION()
WORDS() XOR()
For information on a particular flag, type 'help <functionname>'.
It may be necessary to include the parentheses in the function name,
like 'help v()'.
& GENDER
Topic: GENDER
A player's (virtual) gender is specified in the Sex attribute. This
attribute controls how gender-specific pronoun substitutions are evaluated
for the player. If the player's Sex attribute starts with an 'M' or an 'm'
then the player is assumed to be male, 'F', 'f', 'W', and 'w' indicate
female, and anything else indicates neuter.
See also: SUBSTITUTIONS.
& GOALS
Topic: GOALS
There is no ultimate goal to this game, except to have fun. There are
objects and places to build, puzzles to solve, scenery to visit, and people
to meet. There are no winners or losers, only fellow players. Enjoy.
& HERE
Topic: HERE
The word 'here' refers to the room you are in (if you are inside an object,
it refers to the object that you are in, not the room that the object is
in). For example, to rename the room you are in (if you control it), you
could enter '@name here= <new name>'.
& HOMES
Topic: HOMES
Every thing or player has a home. This is where things go when sacrificed,
players when they go home, or things with the STICKY flag set go when
dropped. Homes are set with the @link command. A thing's home defaults to
the room where it was created, if you control that room, or your home. You
can link an exit to send players home with '@link <dir>=home'. Drop-tos
can also be set to 'home'.
See also: @link, DROP-TO, STICKY.
& LINKING
Topic: LINKING
You can link to a room if you control it, or if it is set LINK_OK or ABODE.
Being able to link means you can set the homes of objects or yourself to
that room if it is set ABODE, and that you can set the destination of exits
to that room if it is LINK_OK.
See also: @link, ABODE, LINK_OK.
& LISTENING
Topic: LISTENING
Thee are two ways to listen for something in a room. The easiest way
is to use a combination of @listen and @ahear/@aahear/@amhear. The
second way is to use a "^" pattern in an attribute, similar to the way
"$" is used for user-defined commands. The attribute takes the form:
'^<pattern>:<action>'.
The ^-pattern check is only performed on objects with their MONITOR flag
set. The criterion for triggering a pattern-listen is the same as that for
triggering an @ahear - the object cannot trigger its own listen patterns.
All matching attributes have their <action>s performed, not just the first.
Also, attributes with the no_command flag set are not checked for ^-patterns.
Example:
> @va test = ^* says "foo *":say I got a foo with %1!.
Set.
> @set test=monitor
test grows ears and can now hear.
> say foo bar
You say "foo bar"
test says "I got a foo with bar!."
See also: @ahear, @listen, @set.
& LISTS
Topic: LISTS
A list is a string, usually stored in an attribute (currently any of the
va-vz attributes), which is a series of words, separeated by one or more
spaces. The following would be a list (denoted on the ends by ', which is
not actually in the string): 'one two three four five'. The functions
first(), rest(), cat(), member(), and remove(), all work on lists.
See also: cat(), first(), member(), remove(), rest().
& LOOPING
Topic: LOOPING
Looping in an object can have its good parts and its bad parts. The good
part is when you activate part of a program multiple times to exaustively
preform an operation. This is usually done by:
@va object = <list of commands>;@trigger me/vb
@vb object = @switch <test> = <false>,@trigger me/va,<otherwise go on>
Looping can be a problem when it goes on without stopping. The @ps command
can be used to see if you are looping. Beware! A looping machine that
isn't @halt'ed will drain your money supply while you are away!
See also: @halt, @ps.
& ME
Topic: ME
The word 'me' refers to yourself. Some things to do when starting out:
1) give yourself a description with
'@describe me = <description>', then look at yourself with 'look me'.
2) set your gender, if you wish it known, with
'@set me=male' or '@set me=female' (or '@set me=neuter' to be an 'it').
& MONEY
Topic: MONEY
You need money to build within the game, to run programmed objects or use
certain other commands, or to buy things from vendors set up by other
players. You can get money via one or more of these methods:
1. You receive a daily allownace for each day you connect.
2. You have a chance of finding money as you wander around areas that
other people have built.
3. You can find valuable objects and sacrifice them at the temple.
See also: @list costs, COSTS, SACRIFICING.
& PUPPETS
Topic: PUPPETS
An object is made into a puppet by doing '@set <object>=puppet', once an
object is a puppet it will relay all that it sees and hears to its master.
All objects created by a puppet are owned by its master, when puppets spend
or earn money, they use their master's money supply. In order to prevent
puppets from screwing up puzzles, objects may have the KEY flag set, this
will prevent puppets from picking the object up. A puppet may be commanded
by its master by '@force <object>=command', or by the shorthand version,
'#<number of puppet> command'. The puppet flag is handy for debugging, as
it allows you to see the result messages your object generates.
Example:
@force fred="hi there. -or- #4342 "hi there.
See also: VERBOSE.
& ROBBERY
Topic: ROBBERY
Robbing is not allowed on this MUSH. If you really need money, ask your
friendly neighborhood wizard.
See also: MONEY.
& SACRIFICING
Topic: SACRIFICING
You sacrifice a thing by dropping it in the temple. Sacrificing an object
gives you the value of an object. You can't sacrifice something you own and
get money for it. If you have more than 10000 coins, all sacrifices are
worth only 1 coin. The sacrifice value of a thing is set at creation by
'@create frob=cost', by the formula value=(cost/5)-1.
& SEMAPHORES
Topic: SEMAPHORES
Semaphores may be used for synchronizing complex objects or for enforcing
mutual exclusion. You may use any object you own or any LINK_OK object as
a semaphore, and any type of object (thing, room, player, or exit) may be
used.
The semaphore state of an object is shown by the Semaphore attribute (which
is read-only); a positive number indicates the number of commands awaiting
notifies, and a negative number indicates the number of waits on that
semaphore that will not block.
Use the '@wait <object>' form of the @wait command to request a command be
delayed until <object> is notified with the @notify command. The @drain
and @notify_all clear the semaphore on <object>, either discarding or
executing all pending commands. Remember that the object performing the
@wait executes the command, not the object used as a semaphore.
{ 'help semaphores2' for more }
& semaphores2
You may also combine the semaphore and timer options of @wait with
'@wait <object>/<timeout> = <command>' If the time period expires before
the semaphore is notified, then the command is executed and the semaphore
count is decremented, just as if the command had been run because the
semaphore had been notified.
Examples: <simple> @wait semaphore="Foo
@notify semaphore
<mutex lock> @va mutex lock=@wait me=@trig me/vb
@vb mutex lock="Got it!;@notify me
@startup mutex lock=@notify me
<timed wait> @wait timer/60 = "Sixty Second Timer.
In the above examples you will say "Foo" after semaphore is notified,
you will say "Got it" when you have the mutual exclusion lock mutex lock
(You could have also modified object registers that need to be protected
from concurrent update), and you will say "Sixty Second Timer." either when
timer is notified or after sixty seconds pass.
See also: @drain, @notify, @notify_all, @wait.
& SPOOFING
Topic: SPOOFING
Spoofing is the act of making other characters think that a person said or
did something that they did not. This is very easy to accomplish, and has
some good effects, which is why it is allowed. Overabuse of this feature
will result in its being made a wizard-only feature, not to mention perhaps
bringing down a few @toads on people.
& STACK
Topic: STACK
Command lists that are run on objects can have up to 10 stack values
named %0 through %9 (or [v(0)] through [v(9)]). Stack values can be set
by the @trigger command, or by matching wildcard characters in the Listen
attribute (in the case of the Ahear, Aahear, and Amhear attributes).
Example: @listen item=* foo *
@ahear item= [v(1)] bar [v(0)].
& SUBSTITUTIONS
Topic: SUBSTITUTIONS
All messages may contain %-substitutions, which evaluate to gender-specific
pronouns if the player's gender is set or to other useful information.
Information returned is based on the player that caused the message to be
displayed, not the object that stored the message or which is running the
action list. The substutitions available are:
%s, %S = Name, he, she, it. (subjective)
%o, %O = Name, him, her, it. (objective)
%p, %P = Name's, his, her, its. (possessive)
%n, %N = the player's name.
%r = carriage return
%t = tab character
%b = space character
%% = literal '%' character
%0-%9 = Stack value.
%va-%vz = Contents of attribute va through vz
%# = Database number of the object that caused the message to be
diplayed or the action list to be run.
%! = Database number of the object holding the message
{ 'help substitutions2' for more }
& substitutions2
If the letter following the % is capitalized, the first letter of the
result of the substitution is also capitalized.
Note: %<whatever> is equivalent to [v(<whatever>)], but is more efficient.
See also: GENDER, V().
& SUCCESS
Topic: SUCCESS
You successfully use a player or a thing when you take it (because you
passed the lock). You successfully use an exit when you go through it.
You successfully use a room when you look around and the room is not locked
against you.
See also: get, look, @asuccess, @lock, @osuccess, @success.
& SWITCHES
Topic: SWITCHES
Some commands have command switches associated with them that can be used
to modify their behavior. For instance, switches on the @ps command
control the amount of information displayed, and switches on the @switch
command indicate whether to perform all actionlists whose targets match
the search string, or just the first.
See also: @list.
& OBJECT TYPES
Topic: OBJECT TYPES
There are 4 types of objects: things, players, exits, and rooms. The first
letter following an object's ID number indicates the type: P(layer),
E(xit), R(oom), otherwise, thing. Things are inanimate objects that can
be carried. Players are animate objects that can move and carry. Exits
are the means by which objects move from room to room. Rooms are locations
that contain objects and linked exits.
& COMMAND EVALUATION
Topic: COMMAND EVALUATION
When you submit a command to be executed by MUSH (whether by typing it in or
by having a machine run it, the following steps are performed, in sequence.
If the command matches something in a step, the matching actions are
performed and the walk down the list stops.
- If the command was typed in, it is checked against the uppercase-only
commands (QUIT, WHO, etc). If so, the command is executed.
- The first letter of the command is checked to see if it is a single-
character command (", :, etc). If so, %-substitution and function
evaluation may be performed (depending on the command), and the command
is executed.
- The command is checked to see if it is the 'home' command. If so, the
player or object performing the command goes home.
- The command is checked against the exits in its current room. If one
matches, it is performed. If more than one matches, one is picked randomly
from the exits for which the player passes the lock (If the player does not
pass any locks, then the exit to be tried is picked randomly.
{ 'help command evaluation2' for more }
& command evaluation2
- The first word of the command is checked to see if it is an internal MUSH
command. If so, the remainder of the command is broken up into arguments,
%-substitution and function evaluation may be performed on the (split up)
arguments, and the command is executed.
- %-substitution and function evaluation is performed on the command.
- All objects in the player's inventory, all objects in the player's
location, and the location itself are searched for $-commands that match
the command. All that match are performed. The player may or may not be
checked, depending on how the MUSH is configured.
Note: Commands that can cause other commands to be executed (such as @wait,
@switch, @trigger, etc) never perform substitution on their arguments, they
leave the evaluation to the command that is to be executed. This prevents
most of the problems with getting objects to perform unintended commands by
putting a ';', '}', or ',' in an argument. The @force command is an
exception in that it evaluates its argument, so it should be used with
caution (preferably by never using it to pass information that someone else
entered, use @trigger instead).
Also, the construct '$xx *:%0' does not work (and is very dangerous
programming), use '$xx *:@force me=%0' if you need this functionality.
& VERBS
Topic: VERBS
For many verbs there are three attributes that specify messages and actions
associated with the verb in addition to the verb's builtin action.
The attributes are named Verb, Overb, and Averb. Verb is the message that
the enactor sees, Overb is the message that everyone else in the same room
as the enactor sees, and Averb is a list of commands that are run.
These attributes may be set using the @<attribute> command, so the commands
to set the attributes related to the 'drop' command are @drop, @odrop, and
@adrop.
& WIZARDS
Topic: WIZARDS
Wizards are the people that help run the game and make sure that everything
is working properly. They have special powers to tweak reality in ways
mortals can only dream of. Be nice to them, they are going out of their
way to help keep the game running smoothly.
& V()
Function: v(<string>)
The V function can be used as an alternative for percent (%) substitution
and also as a replacement for get(me/<arg>). If the argument is two
characters long or longer and starts with a letter, then the object
performing the v() call (and its parent, if necessary) is searched for the
named attribute, and its value is returned if possible. Otherwise, a
percent substitution is performed on the argument (so that v(o) is
equivalent to %o, for instance). The percent form (%o in the previous
example) is preferred as it is faster, and there are no longer any security
problems associated with it. Note that attributes with single-character
names cannot be retrieved with v().
See also: GENDER, SUBSTITUTION, PARENT OBJECTS.
& wordpos()
Function: wordpos(<string>,<charpos))
Returns the number of the word within <string> where the character position
<charpos> falls. Spaces between words are treated as belonging to the word
that follows them. If <charpos> is not within the string, the value #-1 is
returned. Both words and characters are numbered starting at 1.
Example:
> say wordpos(This is a test, 4)
You say "1"
> say wordpos(This is a test, 5)
You say "2"
> say wordpos(This is a test, 6)
You say "2"
> say wordpos(This is a test, 20)
You say "#-1"
& type()
Function: type(<object>)
Returns a string indicating the object type of <object>, either EXIT,
PLAYER, ROOM, or THING.
Example:
> say type(me)
You say "PLAYER"
> say type(here)
You say "ROOM"
& hasflag()
Function: hasflag(<object>,<flag>)
Returns true if object <object> has the flag named <flag> set on it.
You may not be able to retrieve information for objects that you do not
own.
Example:
> say hasflag(me, wizard)
You say "0"
> say hasflag(me, connect)
You say "1"
& delete()
Function: delete(<string>,<first>,<len>)
Returns <string>, but with <len> characters starting after the character
at position <first> removed. In other words, this function copies <first>
characters, skips <len> characters, and then copies the remainder of the
string.
Example:
> say delete(abcdefgh, 3, 2)
You say "abcfgh"
> say delete(Would you like coffee or perhaps tea?, 15, 18)
You say "Would you like tea?"
& lock()
Function: lock(<object>)
Returns the lock on <object>. You must control <object>.
& elock()
Function: elock(<object>,<victim>)
Checks if <victim> would pass the lock on <object>. You must own <object>,
but <victim> can be owned by anyone.
& LWHO()
Function: lwho()
Returns a list of the db numbers of connected players.
Example:
> WHO
Player Name On For Idle Doing
Mortal 00:11 0s
Evinar 00:12 6m
Wizard 00:32 6s
3 Players logged in.
> say lwho()
You say "#226 #271 #1"
See also: WHO
& OBJ()
Function: obj(<object>)
Returns the proper objective pronoun (him, her, it) for referring to
<object>, based on the object's Sex attribute. You must either control
or be near <object>.
& POSS()
Function: poss(<object>)
Returns the proper possessive pronoun (his, her, its) for referring to
<object>, based on the object's Sex attribute. You must either control
or be near <object>.
& SUBJ()
Function: subj(<object>)
Returns the proper subjective pronoun (he, she, it) for referring to
<object>, based on the object's Sex attribute. You must either control
or be near <object>.
& NEARBY()
Function: nearby(obj1,obj2)
Tests if obj1 is near obj2 (if it is in the same location, in obj2's
inventory, or is obj2's location). You must control either obj1 or obj2, or
be near either one of them, if both of these tests fail then 0 is returned.
This function returns 1 if the two objects are nearby and 0 if not.
& GET()
Function: get(<object>/<attribute>)
The get function fetches the specified attribute from the named object.
It can be used to get attributes from objects you own, public attributes
of objects near you, and public attributes other than the description
of players wherever they may be. If the attribute is not present on
<object>, its parent is searched for the attribute.
Example:
> read me
> say get(me/desc)
See also: get_eval().
& GET_EVAL()
Function: get_eval(<object>/<attribute>)
The get_eval function returns the specified attribute from the named object
(just like the get function), except that function references and
%-substitutions have already been performed. In function references,
'me' refers to the object being looked at, and %-substitutions that refer
to the enactor (such as %n, %#, etc) refer to the object making the get_eval
call. If the attribute is not present on <object>, its parent is searched
for the attribute.
Example:
> @va test = This is a get_eval test on %n. The vb is [get(me/vb)]
> @vb test = VB from test
> @vb me = VB from me
> say get(test/va)
You say "This is a get_eval test on %n. The vb is [get(me/vb)]"
> say get_eval(test/va)
You say "This is a get_eval test on Foobar. The vb is VB from test"
See also: get().
& TIME()
Function: time()
Gives you the current time.
WARNING! This is the time on the machine that the mud is running on, and
not where you are.
Example:
> say time()
You say "Thu Dec 19 09:48:06 1991"
See also: secs().
& RAND()
Function: rand(<num>)
Rand returns an interger between 0 and num-1.
Example:
> say rand(10)
You say "6"
> say rand(10)
You say "1"
> say rand(10)
You say "4"
> say rand(10)
You say "9"
> say rand(10)
You say "1"
& EXIT()
Function: exit(<object>)
Exit returns the first exit on the list of exits in the object. Dark exits
are not listed, unless you own the object. Unlike LEXITS(), this function
does not provide information about exits in parent objects.
See also: con(), lcon(), lexits(), next().
& ABS()
Function: abs(<integer>)
Returns the absolute value of its argument.
Examples:
> say abs(4)
You say "4"
> say abs(-4)
You say "4"
> say abs(0)
You say "0"
& MAX()
Function: max(<integer1>,<integer2>[,<integerN]...)
Returns the largest integer from among its arguments.
Up to 30 arguments may be specified.
Examples:
> say max(2,4)
You say "4"
> say max(-100,50,0,25)
You say "50"
See also: min()
& MIN()
Function: min(<integer1>,<integer2>[,<integerN]...)
Returns the smallest integer from among its arguments.
Up to 30 arguments may be specified.
Examples:
> say min(2,4)
You say "2"
> say min(-100,50,0,25)
You say "-10"
See also: max()
& ADD()
Function: add(<integer1>,<integer2>)
Returns the integer sum of the two numbers.
Example:
> say add(2,4)
You say "6"
& SUB()
Function: sub(<integer1>,<integer2>)
Returns the integer result of subtracting <integer2> from <integer1>.
Example:
> say sub(5,2)
You say "3"
& MUL()
Function: mul(<integer1>,<integer2>)
Example:
> say mul(3,5)
You say "15"
& DIV()
Function: div(<integer1>,<integer2>)
Returns the integer quotient from dividing <integer1> by <integer2>.
Example:
> say div(15,3)
You say "5"
> say div(16,3)
You say "5"
> say div(17,3)
You say "5"
> say div(18,3)
You say "6"
See also: mod().
& MOD()
Function: mod(<integer1>,<integer2>)
Returns the integer remainder from dividing <integer1> by <integer2>.
Example:
> say mod(15,3)
You say "0"
> say mod(16,3)
You say "1"
> say mod(17,3)
You say "2"
> say mod(18,3)
You say "0"
See also: div().
& DIST2D()
Function: dist2d(x1, y1, x2, y2)
Returns the integer distance between the Cartesian points in two dimensions
(x1,y1) and (x2,y2).
Example:
> say dist2d(0,0,3,4)
You say "5"
See also: dist3d()
& DIST3D()
Function: dist3d(x1, y1, z1, x2, y2, z2)
Returns the integer distance between the Cartesian points in three
dimensions (x1,y1,z1) and (x2,y2,z2).
Example:
> say dist3d(0,0,0,10,15,20)
You say "27"
See also: dist2d()
& FIRST()
Function: first(<string>)
Returns the first word of a string, that is, everything to the left
of the first space in the string, or the entire string if there are
no spaces in the string.
Example:
> say first(This is a test)
You say "This"
> say first(Would you like coffee, or perhaps tea)
You say "Would"
See also: rest().
& REST()
Function: rest(<string>)
Rest takes a string, returns all the string except the first word,
that is, everything to the right of the first space, or an empty
string, or the empty string if there are no spaces in the string.
Example:
> say rest(This is a test)
You say "is a test"
> say rest(Would you like coffee, or perhaps tea)
You say "you like coffee, or perhaps tea"
See also: first().
& STRLEN()
Function: strlen(<string>)
Returns the number of characters in <string>.
Example:
> say strlen(This is a test)
You say "14"
> say strlen(Would you like coffee, or perhaps tea)
You say "37"
& MID()
mid(<string>, <first>, <length>)
Mid returns a segment of the string, the <length> characters to the
right of the <first> character. Note that the frist character in a
string is numbered zero, and not one.
& COMP()
comp(<string1>, <string2>)
Comp compares two strings. It returns 0 if they are the same, 1 if
string2 is less than/preceeds alphabetically string1, and -1
elsewise.
& S()
s(string)
This function preforms pronoun substitution in a string, and then
returns that string. As usually, %n is the name, %s the subjective
pronoun, %o the objective, and %p the possessive. It is important
to note that the pronoun is that of the triggering object.
So, if the ve of an object were: "[s(This is %n)], and I were to
type @trigger <object>/ve, it would return "This is <myname>", but
if vf were @trigger me/ve, then triggering the vf makes the ve
return "This is <object>"
& POS()
pos(<string1>,<string2>)
This function returns the position that string1 begins in string2,
with the first position being 1.
If string1 is not in string2, then it returns -1.
Example: pos(man,superman) returns 6
& MATCH()
Function: match(<string>,<pattern>)
This function test pattern against each word of the string. The pattern
can contain the wildcards * and ?. ? matches to any one character, while
* matches to any number of characters, including none. So s?x would match
to sex or six, but not to socx, but s*x would match to all of them.
This function returns the number of the first word that matches the pattern,
or 0 if it does not match any of the words in <string>.
See also: LISTS, member().
& EXTRACT()
extract(<string>,<first>,<length>)
Extract returns a string of length words, starting with the first
word. Unlike letters, the first word in a string is number 1,
instead of 0.
A word is assumed to be defined as a string beginning and ending
with a space, or a string w/o any interior spaces.
& FLAGS()
flags(<object>)
Flags returns a string consisting of the flags attached to the
object. The string is, however, just one word. Note that @switch
is case-INsensitive. i.e. p=P as far as it is concerned. I wish
that P=NP....
& NUM()
num(<object>)
Returns the dbref number of the object, which must be in the same
room as the object executing num.
See also: locate().
& CON()
con(<object>)
Con returns the first object in the list of objects carried by
thing. Just the first, and only the first. See NEXT.
& LOC()
Function: loc(<object>)
Returns the number of the location where <object> is. You must either
control the object or be nearby for it to work. When used on an exit it
returns the destination of the exit. You can also use loc() to find the
location of players that are not set UNFINDABLE.
Example:
> look
Mortal's Room(#367R)
A bare room with nothing in it but a bed and a chair.
Contents:
hat(#368)
> say loc(me)
You say "#367"
> enter hat
hat(#368)
Contents:
cat(#325)
> say loc(me)
You say "#368"
> say loc(here)
You say "#367"
See also: room().
& OWNER()
owner(<object>)
Owner returns the dbref of the owner of the object. The object
has to either be yours or else be in the same room as you.
& NAME()
name(<dbref>)
Name returns the name of object (dbref).
& NEXT()
next(<thing>)
If thing is an exit in a room, then next will return the next
nondark exit in the list of exits for that room. If thing is an
object, then next will return the next oject in the inventory list
that the object is in. Otherwise, it returns a '#-1' string.
& AND()
[AND(<boolean value>,<boolean value>)]
Takes two booleans, and returns 1 is the two boolean values are
each equivalent to true(1). See BOOLEAN VALUES.
& OR()
[or(<boolean value>,<boolean value>)]
Takes two booleans, and returns a 1 if at least one of the inputs
is equivalent to true(1). See BOOLEAN VALUES.
& NOT()
[not(<boolean value>)]
Takes a boolean value, and returns it's inverse.
I.E. if the input is equivalent to true(1), it returns a 0, and if
the input is equivalent to false(0), it returns a 1.
See BOOLEAN VALUES.
& XOR()
[xor(<boolean value>,<boolean value>)]
Takes two booleans, and returns a 1 if one, and only one of the two
inputs is equivalent to true(1). See BOOLEAN VALUES.
& gt()
Function: gt(<integer1>,<integer2>)
Takes two integers, and returns 1 if and only if <integer1> is greater than
<integer2>, and 0 otherwise. Warning: passing anything but integers will
produce unexpected results, as non-numeric strings usually are treated
as numeric 0.
Example:
> say gt(4,5)
You say "0"
> say gt(5,5)
You say "0"
> say gt(6,5)
You say "1"
> say gt(foo, bar)
You say "0"
See also: lt(), lte(), gte(), eq(), neq().
& gte()
Function: gte(<integer1>,<integer2>)
Takes two integers, and returns 1 if and only if <integer1> is greater than
or equal to <integer2>, and 0 otherwise. Warning: passing anything but
integers will produce unexpected results, as non-numeric strings usually are
treated as numeric 0.
Example:
> say gte(4,5)
You say "0"
> say gte(5,5)
You say "1"
> say gte(6,5)
You say "1"
> say gte(foo, bar)
You say "1"
See also: lt(), lte(), gt(), eq(), neq().
& lt()
Function: lt(<integer1>,<integer2>)
Takes two integers, and returns 1 if and only if <integer1> is less than
<integer2>, and 0 otherwise. Warning: passing anything but integers will
produce unexpected results, as non-numeric strings usually are treated
as numeric 0.
Example:
> say lt(4,5)
You say "1"
> say lt(5,5)
You say "0"
> say lt(6,5)
You say "0"
> say lt(foo, bar)
You say "0"
See also: lte(), gte(), gt(), eq(), neq().
& lte()
Function: lte(<integer1>,<integer2>)
Takes two integers, and returns 1 if and only if <integer1> is less than or
equal to <integer2>, and 0 otherwise. Warning: passing anything but integers
will produce unexpected results, as non-numeric strings usually are treated
as numeric 0.
Example:
> say lte(4,5)
You say "1"
> say lte(5,5)
You say "1"
> say lte(6,5)
You say "0"
> say lte(foo, bar)
You say "1"
See also: lt(), gte(), gt(), eq(), neq().
& eq()
Function: eq(<integer1>,<integer2>)
Takes two integers, and returns 1 if they are equal and 0 if they are not.
Warning: passing anything but integers will produce unexpected results,
as non-numeric strings usually are treated as numeric 0.
Example:
> say eq(1,-1)
You say "0"
> say eq(5,5)
You say "1"
> say eq(foo, bar)
You say "1"
See also: lt(), lte(), gte(), gt(), neq().
& neq()
Function: neq(<integer1>,<integer2>)
Takes two integers, and returns 1 if they are not equal and 0 if they are
equal. Warning: passing anything but integers will produce unexpected
results, as non-numeric strings usually are treated as numeric 0.
Examples:
> say neq(1,-1)
You say "1"
> say neq(5,5)
You say "0"
> say neq(foo, bar)
You say "0"
See also: lt(), lte(), gte(), gt(), eq(), not().
& cat()
Function: cat(<string1>,<string2>)
Cat returns a string made up of the contents of
string1 followed by the contents of string2, separated by a space.
Example:
> say cat(this is, a test)
You say "this is a test"
& member()
Function: member(<list>,<word>)
Member takes a list and a word, and returns the position of that word
within the list. If the word does not occur in the list, then 0 is
returned. Unlike match(), member() does not check for wildcarding.
A word is defined as a string which has no interior spaces. So ' hello '
would be one word, while 'hello there' would be two.
Example:
> say member(This is a member test, member)
You say "4"
> say member(This is a member test, Member)
You say "0"
> say member(This is a member test, *e*)
You say "0"
> say member(This is a member test, is a)
You say "#-1 CAN ONLY TEST ONE ELEMENT"
See also: LISTS, match().
& remove()
Function: remove(<list>,<word>)
Remove takes a list and a word, and returns the list, with the
word deleted from it. A word is defined as a string which contains
no interior spaces. If the word is not in the list, then the list
is returned.
Example:
> say remove(this is a test, is)
You say "this a test"
> say remove(You can't remove, this)
You say "You can't remove"
> say remove(You can't remove multiple words, You can't)
You say "#-1 CAN ONLY DELETE ONE ELEMENT"
& STARTTIME()
Function: starttime()
Returns a string which is the time the MUSH last rebooted. The time
is in the same format as the TIME() function returns.
Example:
> say starttime()
You say "Sat Dec 7 00:09:13 1991
& SECS()
Function: secs()
Returns the number of elapsed seconds since midnight, January 1, 1970.
This is an easy way to time things.
Example:
> say secs()
You say "692636020"
... wait a bit ...
> say secs()
You say "692636043"
See also: time().
& WORDS()
words(<string>)
Returns the number of words in <string>.
Example:
> say words(This is a test)
You say "4"
say words(Would you like coffee, or perhaps tea?)
> You say "7"
& VERSION()
Function: version()
Returns a string which contains various version information for the MUSH
you're on.
Example:
> version
TinyMUSH Beta version 2.0 patchlevel 0 #3
Build date: Thu Dec 5 10:10:07 EST 1991
> say version()
You say "TinyMUSH Beta version 2.0 patchlevel 0 #3"
& HOME()
home(<object>)
Returns the object's home.
Example:
> exam me
Mortal(#226Pc)
Type: PLAYER Flags: CONNECTED
Desc:Just a plain, old boring Mortal. You know.
Owner: Mortal Key: VA:foobar Clams: 920
Last:Thu Dec 19 08:57:21 1991
Home: Mortal's Room(#367R)
Location: The Town Square
> say home(me)
You say "#367"
& MONEY()
Function: money(<object>)
Returns an integer equal to the amount of money <object> has (if it is a
player) or is worth (otherwise).
Example:
> score
You have 1052 clams.
> say money(me)
You say "1052"
> exam sac test
Sac Test(#287V)
Type: THING Flags: VISUAL
Owner: Beaker Key: *UNLOCKED* Clams: 20
Home: Limbo(#0RLDAJ)
Location: The Town Square
> say money(sac test)
You say "20"
& LCON()
Function: lcon(<object>)
Returns a space-separated list of the contents of <object>.
Example:
> i
t1(#366)
radio(#223)
The Wizard's Pointy Hat(#188SO)
You have 42463 clams.
> say lcon(me)
You say "#366 #223 #188"
See also: lexits(), @dolist.
& LEXITS()
Function: lexits(<loc>)
Returns a space-separated list of the exits in <loc> and its parents.
Dark exits are not returned unless you own the location.
Example:
> look here
The Town Square
You are in the town square. All around you .....
Obvious exits:
foo up southeast sw north
> say lexits(here)
You say "#302 #10 #9 #8 #6"
See also: lcon(), @dolist, PARENT OBJECTS.
& SECURE()
Function: secure(<string>)
Returns <string> after replacing the characters [](){};%\$ with spaces.
This prevents strings entered by players from causing undesired side
effects when used, such as making your object perform unintended commands
or give out information to which you have access. Note that this function
is only needed when the resulting string is to be passed through the @force
command or be used as an attribute for an object (like the success message
for a mail message object).
> @va me=Sneak a peek at Wiz's desc... [get(#1/desc)]
> say secure(%va)
You say "Sneak a peek at Wiz's desc... get #1/desc "
> say secure($foobar:this {is} a really, tough ; test.)
You say " foobar:this is a really tough test."
Note: 'say secure(Sneak a peek at Wiz's desc... [get(#1/desc)])' does not
produce the expected result because the argument is evaluated BEFORE being
processed by secure(), therefore the [get()] call has already been
performed.
See also: escape().
& ESCAPE()
Function: escape(<string>)
Returns <string> after adding an escape character (\) at the start of the
string and also before each of the characters %;[]{}\ that appear in the
string. This prevents strings entered by players from causing undesired
side effects when used, such as making your object perform unintended
commands or give out information to which you have access. Note that this
function is only needed when the resulting string is to be passed through
the @force command or be used as an attribute for an object (like the
success message for a mail message object). This function has the
advantage over the secure() function in that the string the user sees
after evaluating it is the same as the original string.
Example:
You say "\Sneak a peek at Wiz's desc... \[get(#1/desc)\]"
Note: 'say escape(Sneak a peek at Wiz's desc... [get(#1/desc)])' does not
produce the expected result because the argument is evaluated BEFORE being
processed by escape(), therefore the [get()] call has already been
performed.
See also: secure().
& MUDNAME()
Function: mudname()
Returns the name of the MUD. This is usually (but not necessarily) the name
that appears in the various mud lists, and is the name that the mud is
listed under in reports from RWHO servers (that is, if the mud sends its
WHO information to an RWHO server).
Example:
> say mudname()
You say "TestMUSH"
& CAPSTR()
Function: capstr(<string>)
Returns <string> with the first character capitalized. If the first
character is not a letter, this function returns the string unmodified.
Example:
> say capstr(this is a string I want capitalized)
You say "This is a string I want capitalized"
See also: lcstr(), ucstr().
& LCSTR()
Function: capstr(<string>)
Returns <string> with all letters converted to lowercase.
Example:
> say lcstr(This is something I want to TEST)
You say "this is something i want to test"
See also: capstr(), ucstr().
& UCSTR()
Function: capstr(<string>)
Returns <string> with all letters converted to uppercase.
Example:
> say ucstr(This is a test, really!)
You say "THIS IS A TEST, REALLY!"
See also: capstr(), lcstr().
& LNUM()
Function: lnum(<number>)
Returns a list of numbers from 0 to <number>-1.
Example:
> say lnum(5)
You say "0 1 2 3 4"
& LATTR()
Function: lattr(<object>)
Returns a list of the attributes set on <object>.
Example:
> exam me
Mortal(#226Pc)
Type: PLAYER Flags: CONNECTED
Desc:Just a plain, old boring Mortal. You know.
Owner: Mortal Key: VA:foobar Clams: 920
VC:Mon Sep 9 12:09:01 1991
VE:baz
Last:Thu Dec 19 08:57:21 1991
VV(#2+):Foof!
Domain:Abusees
Contents:
testobject
Home: Limbo(#0RLDAJ)
Location: The Town Square
> say lattr(me)
You say "Desc VC VE Last VV Domain"
See also: @dolist.
& REVERSE()
Function: reverse(<string>)
Reverses the order of the characters of <string>.
Examples:
> say reverse(This is a test)
You say "tset a si sihT"
> say reverse(This is a test, Really...)
You say "...yllaeR ,tset a si sihT"
> say reverse(A man, a plan, a canal -- Panama!)
You say "!amanaP -- lanac a ,nalp a ,nam A"
See also: revwords().
& REVWORDS()
Function: revwords(<string>)
Reverses the order of the words of <string>. A word is considered to be
any sequence of nonblank characters, separated by blanks, so punctuation
characters that follow a word are considered part of the word.
Examples:
> say revwords(This is a test, Really...)
You say "Really... test, a is This"
> say revwords(Was it a cat I saw?)
You say "saw? I cat a it Was"
See also: reverse().
& BEFORE()
Function: before(<string1>,<string2>)
Returns the portion of <string1> that occurs before <string2>. If <string2>
does not occur in <string1>, the entire string is returned.
If you want to return the portion of the string after the first space,
use the first() function instead.
Examples:
> say before(This is a test,a)
You say "This is "
> say before(This is a test,is)
You say "Th"
> say before(This is a test, nope)
You say "This is a test"
See also: after(), first(), rest().
& AFTER()
Function: after(<string1>,<string2>)
Returns the portion of <string1> that occurs after <string2>. If <string2>
does not occur in <string1>, a null string is returned.
If you want to return the portion of the string after the first space,
use the rest() function instead.
Examples:
> say after(This is a test,a)
You say " test"
> say after(This is a test,is)
You say " is a test"
> say after(This is a test, nope)
You say ""
See also: before(), first(), rest().
& ROOM()
Function: room(obj)
Returns the number of the room that <obj> is in, or would be in if it
executed LEAVE commands until it got to a room. You can find out the
containing room of objects you own, nearby objects, and findable players.
Example:
> i
You are carrying:
hat(#368)
cat(#325)
> look
Mortal's Room(#367R)
A bare room with nothing in it but a bed and a chair.
> say I am in [room(me)], the cat is in room [room(cat)].
You say "I am in #367, the cat is in room #367."
> @fo hat=get cat
cat has left.
> say The cat is in [loc(#325)] within room [room(#325)].
You say "The cat is in #368 within room #367."
See also: loc(), UNFINDABLE.
& SEARCH()
Function: search([<player>] [<class>=<restriction>])
The search() function returns a list of objects that match the search
criteria, which are the same as with the @search command. This function
costs as much as the @search command, so repeated use is expensive.
Caution: if you use the [ and ] characters in an Eval selection you will
need to escape them.
Examples:
> say search()
You say "#226 #289 #325 #364 #368 #369"
> @stats me
6 objects = 0 rooms, 0 exits, 5 things, 1 players. (0 garbage)
> say search(eval=\[eq(money(##),1)\])
You say "#289 #325 #364 #368 #369"
> say search(player=wizard)
You say "#1"
See also: @search.
& STATS()
Function: stats([<player>])
This function returns information about the number of objects on the MUSH,
much like the @stats command. If the argumet is omitted or is 'all', then
the stats for the entire MUSH are returned, otherwise the stats for the
named player are returned. You can only get stats for yourself.
The stats are returned as a set of 6 numbers, in the same order as reported
by the @stats command: total objects, rooms, exits, things, players, and
garbage. This command costs as much as the equivalent @stats command (ie:
'@stats/all' or '@stats <player>', not the free '@stats').
Examples:
> @stats me
6 objects = 0 rooms, 0 exits, 5 things, 1 players. (0 garbage)
> say stats(me)
You say "6 0 0 5 1 0"
> say stats()
You say "377 51 165 134 20 7"
> @stats/all
377 objects = 51 rooms, 165 exits, 134 things, 20 players. (7 garbage)
See also: @stats.
& ITER()
Function: iter(<list>,<eval>)
<list> is a space-separated list of strings, which can be object numbers,
attributes, or arbitrary words. <eval> is a string that is to be evaluated
once for each item in <list>, replacing the special symbol ## with the
corresponding item from <list>. A list of the results of these evaluations
is returned to the caller. The effect is very similar to @dolist, except
that the results are made into a list and returned, not executed.
Warning: you need to put <eval> inside curly braces. This prevents <eval>
from being evaluated before iter() gets a chance to see it. If you need to
put [] delimiters in <eval> (because you want the result of more than one
function) then you need to escape the [] delimiters.
Examples:
> say iter(This is a test,strlen(##)) << forgot the { } >>
You say "2 2 2 2"
> say iter(This is a test,{strlen(##)})
You say "4 2 1 4"
> say iter(lnum(10),{mul(mul(##,##),10)})
You say "0 10 40 90 160 250 360 490 640 810"
> say iter(lcon(me),{\[name(##)\]..\[money(##)\]}) << escaped [ ] >>
You say "test..1 t1..1 radio..1 The Wizard's Pointy Hat..1"
See also: @dolist.
& LOCATE()
Function: locate(<looker>,<string>,<where>)
The locate function is used to look for an object from the perspective of
<looker> (You must own <looker>). The database number of the item that
is found is returned. The <where> parameter specifies a list of places to
look, from this list:
a - Look for absolute references (#<number>)
c - Look for exits carried by <looker> (and by <looker>'s parents).
e - Look for exits in <looker>'s location (and the location's parents).
h - Look for 'here', which matches <looker>'s location.
i - Look in <looker>'s inventory.
m - Look for 'me', which matches <looker>.
n - Look for <looker>'s neighbors (other objects in the same location).
p - Look for player names prefixed by a '*'
* - Look for everything in the above list.
{ 'help locate2' for more }
& locate2
You may also specify qualifiers in <where> to help resolve possible
ambiguities:
E - Prefer exits over other types.
L - Prefer unlocked exits over locked exits.
P - Prefer players over other types.
R - Prefer rooms over other types.
T - Prefer things over other types.
V - Report "Can't find..." and "Which one..." errors to <looker>.
If nothing matches, the value #-1 is returned. If more than one thing
matches, but nothing matches exactly, the value #-2 is returned. If more
than one thing exactly matches, one is chosen at random. If you specify
more than one type preference (E, P, R, or T), then the last one entered
is the one that is obeyed. The default is for no type to be preferred.
Examples:
> i
test1(#378)
test(#376)
You have 42463 clams.
> look
Nullspace(#250R)
test1(#382)
> say locate(me,test,i)
You say "#376"
{ 'help locate3' for more }
& locate3
> say locate(me,test,n)
You say "#382"
> say locate(me,test1,in)
You say "#378"
> say locate(me,test1,in)
You say "#382"
> say locate(me,tes,in)
You say "#-2"
> say locate(here,tes,*)
You say "#382"
> say locate(me,out,e)
You say "#252"
> say locate(me,here,*)
You say "#250"
See also: num(), PARENT OBJECTS.
& EDIT()
Function: edit(<string>,<from>,<to>)
This function edits <string>, replacing all occurrences of the substring
<from> with the string <to>. If <from> is '$', then <to> is appended to
<string>, while if <from> is '^', then it is prepended.
Examples:
> say edit(This is a test,is,x)
You say "Thx x a test"
> say edit(Atlantic,^,Trans)
You say "TransAtlantic"
See also: @edit.
& U()
Function: u([<obj>/]<attr>[,<arg>]...)
The u function evaluates an attribute, either from the object performing the
function or from another object you own, passing in arguments and returning
the result.
Examples:
> @va me=Word is [extract(v(vb),add(%0,1),1)], arg2 is %1.
> @vb me=This is a test of the u function.
> say u(va,4,Testing 123)
You say "Word is of, arg2 is Testing 123."
> say u(va,7)
You say "Word is function., arg2 is ."
> say u(me/va,6,Foobar)
You say "Word is u, arg2 is Foobar."
See also: s(), v(), get(), get_eval().
& SWITCH()
Function: switch(<str>[,<pat1>,<res1>]...[,<dflt>])
The switch function compares <str> against <pat1>, <pat2>, etc (allowing *
to match any number of characters and ? to match any 1 character), and
returns the corresponding <resN> parameter for the first <patN> pattern
that matches. If none match, then the default result <dflt> is returned.
Example:
> say switch(c,*a*,A,*b*,B,*c*,C,*d*,D,E)
You say "C"
> say switch(f,*a*,A,*b*,B,*c*,C,*d*,D,E)
You say "E"
> say switch(cab,*a*,A,*b*,B,*c*,C,*d*,D,E)
You say "A"
> say switch(f,*a*,A,*b*,B,*c*,C,*d*,D)
You say ""
See also: @switch, match().
& SPACE()
Function: space(<count>)
Returns the number of indicated spaces. If <count> is missing or cannot
be converted to a number, one space is returned. This function is useful
when you want to pass a single space (or more than one) as a function to an
argument, because normally leading and trailing spaces are stripped from
function arguments.
Examples:
> say space(4)
You say " "
> say edit(Foo bar bletch, space(), X)
You say "FooXbarXbletch"
& PARENT()
Function: parent(<obj>)
Returns the parent of <obj>. Returns #-1 if <obj> cannot be found or
if you do not own <obj> and it is not set VISUAL.
Example:
> say parent(me)
You say "#-1"
> say My va is [v(va)].
You say "My va is "
> @parent me=test
Parent set.
> say parent(me)
You say "#323"
> say My va is [v(va)].
You say "My va is Testing 123"
See also: @parent, PARENT OBJECTS.
& SIGN()
Function: sign(<number>)
Returns -1, 0, or 1 depending on whether its argument is negative, zero, or
positive (respectively).
Example:
> say sign(-4)
You say "-1"
> say sign(4)
You say "1"
> say sign(0)
You say "0"
> say sign(-1)
You say "-1"