& 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
If there are any errors in the help text, please notify a wizard
in the game, or send mail to lwl@eniac.seas.upenn.edu
All commands listed in this file might not apply to all mushes running
this code. This is because some of the commands/effects can be enabled or
disabled by the site admin of your MUSH. If a command is not available
AND it is documented, ask your site admin why it isn't enabled.
& COMMANDS
Help is available for the following MUSH Commands:
brief DOING drop examine enter
get give goto kill leave
look move news page pose
QUIT read RWHO say score
slay take throw use whisper
WHO " : ;
In addition to these, there are '@' commands. @-commands usually are
commands which can modify and affect the database in substantial ways.
There are several types of '@' commands. The following help entries
list available '@' commands:
@-ATTRIBUTES @-BUILDING @-GENERAL @-WIZARD
& @-ATTRIBUTES
'@' commands which are attribute-related set game-defined attributes.
These are:
@aahear @aconnect @adeath @adescribe @adisconnect
@aefail @aenter @afailure @ahear @aleave
@amhear @amove @apayment @asuccess @ause
@away @charges @cost @death @describe
@does @drop @ealias @efail @enter
@failure @haven @idescribe @idle @lalias
@leave @listen @move @odeath @odescribe
@odrop @oefail @oenter @ofailure @oleave
@omove @opayment @osuccess @ouse @oxenter
@oxleave @payment @runout @sex @startup
@success @use
& @-BUILDING
These '@' commands are building related (they modify the database):
@atrlock @atrchown @chown @chzone @clone
@create @destroy @dig @elock @eunlock
@link @lock @name @nuke @open
@set @ulock @unlink @unlock @uunlock
& @-GENERAL
These '@' commands are general utilities and programming commands:
@config @decompile @doing @dolist @edit
@emit @entrances @find @force @gedit
@halt @lemit @listmotd @mail @oemit
@password @pemit @ps @remit @rwall
@rwallemit @rwallpose @search @stats @sweep
@switch @teleport @trigger @use-does @version
@wait @whereis @zemit
& @-WIZARD
These '@' commands are only usable by wizards:
@allhalt @allquota @boot @chownall @chzoneall
@dbck @dump @login @motd @newpassword
@pcreate @poll @poor @purge @quota
@rejectmotd @shutdown @squota @toad @wall
@wallemit @wallpose @wizemit @wizmotd @wizpose
@wizwall
& topics
Help available on the following Topics:
ATTRIB-OWNERSHIP ATTRIBUTES BEING KILLED
BOGUS COMMANDS BOOLEAN VALUES CONTROL
DROP-TO ENACTOR EVALUATION
EXITS FAILURE FLAGS
FUNCTIONS GENDER HERE
HOMES LINKING LISTENING
LISTS LOOPING MASTER ROOM
NON-STANDARD ATTRIBUTES PUPPETS ROBBERY
SACRIFICING SPOOFING STACK
SUBSTITUTIONS SUCCESS TYPES OF OBJECTS
VERBS ZONES
& CONTROL
CONTROL
<Object> controls <thing> if:
1. <Object> is a wizard.
2. <Object> owns <thing>, and <Object> is a player.
3. <Object> has the same owner as <thing>, and <object> is INHERIT.
4. <Object> has the same owner as <thing>, and the owner is INHERIT.
5. <Object> is in the same zone as <thing>, and <object> passes the
Enter lock of the zone object.
& ZONES
ZONES
Zones are areas of the MUSH which may be controlled by many people.
Essentially, they allow group ownership of objects.
The default zone is NOTHING. Any building done by a player defaults
to belonging to the same zone that the player belongs to.
Every zone is defined by a Zone Master Object (ZMO). The ZMO is an
ordinary MUSH object owned by some player. A wizard may change the
zone of an object or player to a ZMO.
Anyone who can pass the Enter lock of the ZMO has control over all
objects in that zone. This, in essence, gives that player wizard
powers within that zone. For this reason, one must be extremely
careful with the enter locks of ZMOs!
Also, $commands on a ZMO are treated as global within that zone.
The game attempts to match $commands for the ZMO of the player's
location, as well as $commands for the player's own zone.
For some suggestions on how to use zones, see "help zones2".
& ZONES2
Some suggested uses of zones:
1. If you are working on a building project with several people, it
may be useful to create a zone object and @elock it to all of you,
and ask a wizard to @chzone the players involved to the zone object.
That way, all of the players working on the project will be able to
modify the building.
2. On a similar thread, if several players are working on a project
involving only a few objects, it may be simpler to create a zone
object and @chzone those few objects to the ZMO instead of resetting
the zones of the players. Note that a player does not have to belong
to a zone in order to change objects in that zone; all is merely
required to pass the ZMO's enter lock.
3. If local wizards are desired, a zone object may be created and enter
locked to the local wizard. Players building within that zone should
be @chzone'd to that ZMO. The local wizard will then be able to
control anything within that domain.
4. If you want restricted global commands defined over only a small area,
you can define that area to be part of a zone, and place the desired
$commands upon the ZMO.
& MASTER ROOM
MASTER ROOM
The Master Room enables global commands and exits. Exits in the Master
Room may be used from any location on the MUSH. All objects left in the
Master Room are checked for user-defined $commands. Those $commands are
considered global. Normally, only wizards will have access to the Master
Room. See "help EVALUATION" for details on global commands.
& EVALUATION
EVALUATION ORDER
Commands are mated in the following order:
Special game commands: WHO, QUIT, etc.
"home" command
Single-token commands: ", :, ;
Exits in the room
@-commands
Regular game commands: get, inventory, etc.
Enter aliases
Leave aliases
User-defined commands on nearby objects. All such $commands are matched
and executed.
If there are no user-defined commands nearby:
User-defined commands on the zone of the player's location
User-defined commands on the player's personal zone
If nothing, including zone commands, has been matched:
Global exits
Global user-defined commands: all $commands in the Master Room are
matched. Local commands are always checked first and ALWAYS negate
global commands.
& LASTSITE
LASTSITE
This attribute gives the name of the site you last connected from.
Mortals cannot set it.
& @mail
@mail [<player>, <msg #>, <command> [= <msg>, <msg #>]]
@mail is just what it says, it is a function to send mail to users and
recieve mail from users. There are many things that can be done with
it, including the passing of descriptions, functions, whatever may have
you. Here is a summary of how to use it:
@mail by itself will give you a brief list of all your mail with the user
name, time the mail was sent, and will mark all NEW mail with a * in
front of the message. All the numbers listed here are the ones used
when you see <msg #>.
@mail <player> = <msg>
This sends the message <msg> to <player>. All function subsitutes
are valid in <msg> including mail(#) which will allow you to forward
mail you have recieved to other users.
Type 'help @mail2' to continue:
& @mail2
@mail <msg #>
This displays the message from your mailbox that has the number
<msg #>...
@mail <msg #> = <msg>
This sends <msg> to the user that sent you the message in your
mailbox that has the number <msg #>. <Essentaly a 'reply', but
no special effects, just sends <msg> normally>
@mail clear
This clears ALL mail from your mailbox, unread or not.
@mail clear = <msg #>
This clears only the message <msg #> and renumbers any messages
recieved after <msg #>.
@mail mdb-stats
This wizard-only function displays the size of the mail database.
Thanks go to Joarm and Spellbound MUSH for this code addition.
& @config
@config
This command lists the MUSH configuration parameters, indicating what
special things are enabled, and the cost of certain commands. If
something doesn't work the way you expected it to, it might be wise to
use this command and check the configuration paramters.
& @dolist
@dolist <list> = <action>
@dolist executes the <action> for each element in <list>. If <list> is a
function, it will be evaluated to obtain the necessary list to use. It
may be any space-separated list of strings, which can be object numbers,
attributes, or arbitary words.
<action> is a command or list of commands enclosed in braces { }
and is performed once for every item in <list>. The special symbol "##"
is replaced by the corresponding item from <list>.
Example: @dolist [lcon(here)] = "[name(##)]
would cause you to say the name of all objects in the room.
Note: the stack variables %0 to %9 do not function very well with @dolist.
It might be advisable to store temporary information in V-attributes
instead.
& @ealias
@ealias <object> = <enter alias>
This allows a player to type the enter alias instead of "enter <object>"
If you have a chair, you coud "@ealias chair = sit down" and then just
type "sit down" instead of "enter chair" - using the object name is
not necessary. Note that the enter alias is checked after normal exits.
& @lalias
@lalias <object> = <leave alias>
This allows a player to type the leave alias instead of the "leave"
command, in a fashion similar to enter aliases (see @ealias for details).
& @away
@away <player> = <message>
This message is sent to a player who tries to page you when you are
not connected.
& @haven
@haven <player> = <message>
This message is sent to a player whose pages you are refusing, either
through use of the HAVEN flag or through the use of a page lock.
& @idle
@idle <player> = <message>
This message is sent in return to every page which successfully reaches
you. It is useful if you are idle for long periods of time and wish to
inform people where you are, or if you are in a meeting and cannot
quickly return pages.
& @ulock
@ulock <object> = <key>
This type of lock is a use-lock for objects, and a page-lock for players.
On an object, this restricts who may trigger the "@use" set of registers,
and who may use the $commands on the objects. If the person who is trying
to use the object or its special commands, cannot pass the lock, he is
told, "Permission denied." On a player, it restricts who is allowed to
page that person. If the paging person cannot pass the lock, the target
player is treated as if he were set HAVEN. Indirect locks and other
special locking styles are supported; see "help @lock" for details.
Example: if I want everyone but Bob to be able to page me, I would
"@ulock me=!*Bob". If I want only Bob to be able to page me, I would
"@ulock me=*Bob".
& @uunlock
@uunlock <object> = <key>
Page-unlocks a player or use-unlocks a thing. Someone who is page-unlocked
may be paged by anyone; an object which is use-unlocked may be used by
anyone. See "help @ulock" for more.
& @efail
@efail <object> = <message>
This is the message shown to the player who fails to enter the object.
& @oefail
@oefail <object> = <message>
This message is shown to the location of a player who fails to enter
the object.
& @aefail
@aefail <object> = <action>
This is the action taken by the object when a player fails to enter it.
& @elock
@elock <object> = <key>
Enter-locks an object, restricting who is allowed to enter it. Special
lock types are supported (see "help @lock" for details). Only objects
which are ENTER_OK may be entered, regardless of the key.
& @eunlock
@eunlock <object>
Enter-unlocks an object, in a fashion similar to @unlock. For anyone
to be able to enter an object, it must be both @eunlocked and ENTER_OK.
& @nuke
@nuke <object>
Destroys an object, overriding the SAFE flag. Aside from this
feature, it is identical to @destroy.
& drop
drop <object>. Drops <object>. Dropping a thing in the temple
sacrifices it (See SACRIFICING). Otherwise, a dropped thing is
relocated to the current room, unless its STICKY flag is set
(See STICKY), or the room has a drop-to (See DROP-TOs). Unlinked
exits can only be dropped in rooms you control. 'throw' is the
same as 'drop'.
& examine
examine <object>[/attribute]. Displays all available information
about <object>. <object> may be an object, 'me' or 'here'. You must
control the object to examine it. If you do not own the object, or
it is not visible, you will just see the name of the object's owner.
May be abbreviated 'ex <object>'. If the attribute parameter is
given, you will only see that attribute (good for looking at code).
You can now wild-card match on attributes. For example. to see all
the attributes that began with a 'v' you could do ex <object>/v*
& brief
brief <object>. It is identical to "examine", except that it does
not print the attributes on an object. This is useful for just
glancing at an object to determine its home, owner, lock, etc.
& get
get <object>. Picks up <object>. <object> can be a thing or an
unlinked exit. 'take' is the same as 'get'.
You can now also do get <thing>'s <object>. It will fail if
either thing is not ENTER_OK or object is locked against you.
& give
give <player>=<Marks/object>. Gives player the specified number of
Marks or <object>. You can't give someone Marks if their new total
would be greater than 10000 Marks. (No reason to get greedy) You
may also give players objects, but the other player must be set to
enter_ok (See FLAGS) to receive something you give.
& goto
go[to] <direction>; go[to] home. Goes in the specified direction.
'go home' is a special command that returns you to your starting
location. The word 'go' may be omitted. 'move' is the same as 'go'.
& inventory
inventory. Lists what you are carrying.
Can be abbreviated by just 'i', or 'inv'.
& kill
kill <player> [=<cost>]. Attempts to kill the specified player.
Killing costs <cost> Marks, which gives you a <cost>% chance of
killing the player. Thus, spending 100 Marks always works (except
against wizards, who can never be killed). Players cannot be
killed in rooms which have been set HAVEN. (See FLAGS and HAVEN).
If you don't specify a cost, the default is 10 (i.e. 10%). The
player, if killed, receives <cost>/2 Marks in insurance.
& look
look [object]. Displays the description of <object>, or the room
you're in if object is eliminated. Specifying object as <name> or
#<dbref> or 'me' or 'here' is legal. 'read' is the same as 'look'.
You can also use look to look at object's held by other people,
just use 'look <person>'s <object>'.
'look' may be abbreviated 'l'.
& move
Same as GO. (What, you expect me to type it out twice?)
& news
Shows you the current news for 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.
& page
page [<player>] [=<message>]. This tells a player that you are
looking for them, and tell the player where you are. They will get
a message telling them your name and and location if you omit the
message. This costs 1 Mark. If you include the '=<message>', it
will tell the player your name and your message, but not your
location. If a player is set to HAVEN (See FLAGS), you
cannot page them, and they will not be notified that you tried.
If the player is page-locked against you, he is treated as HAVEN.
Page will also attempt to partial match on the name. If you omit the
player, the game will attempt to page the player you paged last.
If the first character of <message> is a : or a ;, it will send the
page in pose format. (see pose, : and ;)
Objects may page players, but not vice versa. If an object pages
a NOSPOOF player, that player will see the object's number in
square brackets, in front of the message, in a fashion similar to
the way NOSPOOF flags emits.
& QUIT
QUIT. Log out and leave the game. Must be in all capitals.
& read
See 'look'. (See move for reason you have to see look)
& "
See say.
& :
See pose.
& ;
This command is much like pose, however where with pose, the action
and the person's name who commits the action are separated by a
space, with ;, they are not. Example: ;'s watch beeps. -- The room
would see <name>'s watch beeps.
& say
say <message>. Says <message> out loud. You can also use
'"<message>'. See also 'whisper', 'pose', and ';'.
(Note: Say and " append a " to whatever you type in)
& score
score. Displays how many Marks you are carrying. Helpful to see if
any machines are looping. Also see looping, @ps, and most of the
commands that start with @.
& slay
slay <player/object> This is a Wizard command that kills players
without paying any insurance to the victims. It is used in places
where 'suicide' should not pay.
(Su-ic-ide is pain-less... {MASH theme})
& take
See 'get'.
& throw
See 'drop'.
& whisper
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. You can also whisper to things you are carrying,
or to things that are carrying you. whisper <player>=:<pose> also
works, in a fashion similar to page-pose.
'whisper' can be abbreviated by just 'w'.
& WHO
WHO Displays a list of players currently connected to the MUSH.
The WHO tells you how long a player has been on and how long they
have been inactive.
& DOING
This command displays the list of players currently connected to the
MUSH. For mortals, it is identical to WHO. For wizards, it displays
the WHO in the format mortals see. The wizard WHO shows location and
host, but does not show @doing messages. DOING shows @doing messages
but not location or host.
& @poll
@poll <poll question>
This wizard-only command sets the "poll" - the Doing question. If
"@poll" is used by itself, the question is reset to the default
string "Doing".
& @aahear
An Aahear on an object is activated whenever the listen pattern
matches anything done/said by anything else in the room, and
itself. (Ahear ignores itself, helpful from keeping machines from
triggering itself) See @listen, @ahear, @amhear.
& @adescribe
@adescribe <object> = <actions>. Sets the actions to be taken when
<object> is looked at. Actions are lists of commands separated by
semi-colons and these commands are executed by the object (see
puppet). Things can execute almost any command but rooms and exits
are restricted to forcing objects/puppets to do things. Gender
substitutions are applied to the commands before they are executed,
this allows use of the players name who caused the action. <object>
can be specified as <name> or #<number>, or as 'me' or 'here'. May
be abbreviated @adesc. See also @describe, @idescribe and
@odescribe.
(Note: @adesc's on people are *Extremely Annoying* and may subject
you to *Humiliation* if used. You Have Been Warned. -Leona)
& @afailure
@afailure <object> = <actions>. Sets the actions to be taken on
failure to use <object>. Actions are lists of commands separated by
semi-colons and these commands are executed by the object (see
puppet). Things can execute almost any command but rooms and exits
are restricted to forcing objects/puppets to do things. Gender
substitutions are applied to the commands before they are executed,
this allows use of the players name who caused the action.
<object> can be specified as <name> or #<dbref>, or as 'me' or
'here'. May be abbreviated @afail. See also @fail and @ofail.
& @ahear
@ahear <object> = <actions>. Sets the actions to be taken after a
string set in the @listen (See @listen) is matched. Actions are
lists of commands separated by semi-colons and these commands are
executed by the object (see puppet). Objects can execute almost
any command. Gender substitutions are applied to the commands
before they are executed, this allows use of the players name who
caused the action.
See also @aahear and @amhear.
& @adeath
@adeath <object> = <actions>. Sets the actions to be taken after
<object> is killed. Actions are lists of commands separated by semi
colons and these commands are executed by the object (see puppet)
Objects can execute almost any command. Gender substitutions are
applied to the commands before they are executed, this allows use
of the players name who caused the action.
See also @odeath and @death.
& @amhear
@amhear is like @ahear, only the @listen string/pattern is only
applied to statements/strings that the object itself generates.
@amhear and @ahear together equal @aahear. See @ahear, @listen,
and @aahear.
& @apayment
@apayment <object> = <actions>. Sets the actions to be taken after a
player gives object Marks (see @cost). Actions are lists of
commands separated by semi-colons and these commands are executed
by the object (see puppet). Objects can execute almost any command.
Gender substitutions are applied to the commands before they are
executed, which allows use of the player's name who caused the
action. May be abbreviated @apay. See also @pay and @opay.
& @ause
@ause <object> = <actions>. Sets the actions to be taken when an
object is succesfully "used". Actions are lists of commands separated
by semi-colons. This functions in a similar manner to the other
@a-attributes, such as @asuccess and @apayment.
& @asuccess
@asuccess <object> = <actions>. Sets the actions to be taken on
successful usage of <object>. Actions are lists of commands
separated by semi-colons and these commands are executed by the
object (see puppet). Objects can execute almost any command. Gender
substitutions are applied to the commands before they are executed,
this allows use of the players name who caused the action. It can
be abbreviated @asucc. <object> can be specified as <name> or
#<dbref>, or as 'me' or 'here'. See also @success and @osuccess.
& @does
@does <object> = <actions>. Sets the actions to be taken if someone
performs the @use-does <object> command on this object. The @does
attribute can be triggered by anyone passing an INHERIT check.
& @use-does
@use-does <object>
Triggers the @does attribute on the object in question. If the object
has one, it will run at that time. This command and the @does attribute
are provided for backward compatibility with older versions of Pern code.
& use
use <object>
Attempts to use an object, triggering its @use/@ouse/@ause attributes.
The person using the object must pass its uselock; no inheritance check
is necessary. This is may be done remotely, by using a dbref number;
it provides an easy way for non-INHERIT objects to perform commands on
INHERIT objects.
& @boot
@boot <player>. Disconnects the player from the game. Only Wizards
can use this command, so you better not be naughty! Heh!
(Well, you can be naughty... it's annoying that gets on our nerves.
Ex: @adesc me = kill %N = 100 will get you @booted real quickly.
-Leona)
& @charges
@charges <object> = <integer>. Allows you to limit the # of times
an action can be used. If there is a charges attribute it is
decremented each time an action is triggered, once it reaches zero
actions are disabled. See also @runout.
& @chown
@chown <object>=<player>. Changes the ownership of <object> to
<player>. 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 it
can be @chowned (See FLAGS). In a room, the command used must be
@chown here = <name>, and for an object, you must be very specific.
Note: @chown DOES understand the pronoun me.
Players can't be @chowned; they always own themselves.
& @chzone
@chzone <object>=<zone object>. Changes the zone of <object> to
<zone object>. If <zone object> is "none", the zone is reset to
NOTHING. @chzone'ing a player does not automatically change the
zone of his objects. Only wizards may use this command.
& @chzoneall
@chzoneall <player>=<zone object>. Changes the zone of all objects
owned by <player> to <zone object>. If <zone object> is "none",
the zone is reset to NOTHING. Only wizards may use this command.
& @clone
@clone <object or exit>
For objects, creates an exact duplicate of it and puts it in the
current room. For exits, it creates an exact duplicate of that
exit, except the clone's source is the current room rather than
whatever the original exit's source was.
& @cost
@cost <object> = <amount> Number of Marks that need to be given to
an object to trigger @pay, @opay and @apay. Example:
@cost exit-machine=10
@apay exit-machine=@open %N-exit
@pay exit-machine=Your exit has been created.
& @create
@create <name> [=<cost>]. Creates a thing with the specified name.
Creation costs either <cost> Credits or 10 Marks, whichever is
greater. The value of a thing is proportional to its cost. To be
exact, value=(cost/5)-1. Value cannot be greater than 100, any
values that would be greater than 100 are rounded down to 100.
(see give re: greed)
& @describe
@describe <object> [=<description>]. <object> can be a thing,
player, exit, or room, specified as <name> or #<number> or 'me' or
'here'. This sets the description a player sees when they use the
command 'look <object>'. Without a description argument, it clears
the message. It can be abbreviated @desc. @desc's on everything
that isn't dark is considered to be Good Building Practice.
& @destroy
@destroy <object>. This allows the recycling of objects and returns
the players investment in the object when used. At the present time
the DESTROY_OK flag set on an objects allows any one in possession
of that object to @destroy it. @destroy may be used to recycle any
object but will have a delayed effect on rooms. Rooms are removed
approximately every ten minutes, until then, they have the
Going (G) flag set on them. Should you change your mind, simply
@set <room> = !Going.
(Note: recycling objects is PC!! -Leona)
& @dig
@dig <name> [= <name>[;<other name>]*[,<name>[;<other name>]*]].
Creates a new room with the specified name and displays its number.
This costs 10 Marks. If the [= <name>....*] option is used, the exit will
be opened and linked for you. The [,<exit>...*] option will link a
reverse exit for you.
Example: @dig Kitchen = Kitchen;k;north;n will dig a room called
Kitchen, and open an exit called 'Kitchen' in your current room.
Example 2: @dig Kitchen = Kitchen;k;north;n,out;o;south;s will dig
a room called Kitchen, open an exit called 'Kitchen' in the current
room, AND open an exit 'out' in the room 'Kitchen' leading to the
current room.
The ; symbol means that you may enter the exit by typing
'k','north' or 'n' also. Only the first Exit name is displayed in
the Obvious exits list.
& @drop
@drop <object> [=<message>]. <object> can be a thing, player, exit,
or room, specified as <name> or #<number> or 'me' or 'here'. Sets
the drop message for <object>. The message is displayed when a
player drops <object>. Without a message argument, it clears the
message.
See also @odrop and @adrop.
& @edit
@edit <object>/<attribute> = <search>,<replace> This is used so as
not to have have to retype those obnoxiously long descriptions just
to make one little change. Instead, search and replace via @edit.
<attribute> can be any attribute currently defined on <object>.
<search> and <replace> are two strings. See also ATTRIBUTES.
& @emit
@emit <message> This send message to every person in the current room.
However, no identifier marking it as being sent by you is show. Ie.
@emit foo would show 'foo' to every object in the room.
See also @pemit, @remit, @oemit, NOSPOOF and SPOOFING.
& @failure
@failure <object> [=<message>]. <object> can be a thing, player, exit,
or room, specified as <name> or #<number> or 'me' or 'here'. Sets
the fail message for <object>. The message is displayed when a
player fails to use <object>. Without a message argument, it
clears the message. May be abbreviated @fail. See also @afail and
@ofail.
(Putting @fails on all exits and objects that are locked is
Good Building Practice -Leona)
& @find
@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, this costs 100 pennies.
& @force
@force <player/object>=<command>. Forces the game to act as though
<player/object> had entered <command>. Only wizards may force
players. May be abbreviated @fo. Wizards cannot be forced by
players. Hard luck. You can always force objects you control,
especially puppets. Puppets can be given abbreviated commands in
the form of <name/dbref> <command>. #<dbref>'s are necessary if
the puppet is not in the same room as you. See Puppets.
& @death
@death <player> [=<message>]. <player> can be specified as <name> or
#<dbref> or 'me' or 'here'. Sets the death message for <player>. The
message is displayed when <player> is killed. Without a message
argument, it clears the message. See also @adeath and @odeath.
& @idescribe
@idescribe <object> [=<message>]. Sets object's internal description.
The internal description of an object will be shown to any object
entering it. Without a message argument, it shows the usual @desc.
(see enter, @enter, @oenter, and enter_ok). May be abbreviated @idesc
& @link
@link <object>=<number>; @link <object>=here;
@link <dir>|<room>=home. Links <object> to room specified by
<number>. For things and players, sets the home room (See HOMES).
For rooms, sets the drop-to room (See DROP-TOs). For exits, sets
the target room; exits must be unlinked, and you must own/control
the target room unless its LINK_OK flag is set. Linking an exit
costs 1 Mark. If the exit was owned by someone else, the former
owner is reimbursed 1 Mark. (see @open, @dig)
& @listen
@listen <object> = <string>. A wildcard pattern for an object to
listen for. If/when <string> is heard, the object's ahear is
triggered. Note: if @listen is matched the objects contents will
also hear the message.
& @lock
@lock <object>=<key>. Locks <object> to a specific key(s). <object>
can be specified as <name> or #<number>, or as 'me' or 'here'.
Boolean expressions are allowed, using '&' (and), '|' (or),
'!' (not), and parentheses ('(' and ')') for grouping. To lock to a
player, prefix their name with '*' (ex. '*Moonchilde').
Example:
@lock Purse = me|*Darling will lock object purse so that only you
or player Darling can take it.
New lock features:
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.
@lock a-f=name:<g will lock the exit a-f against any one whose
name is higher than f.
Indirect, Carry, and Is locks are now also possible.
**See help @lock2 for more information **
**on Indirect, Carry, and Is locks. **
& @lock2
Indirect locks -- locks an object to the lock of the specified
object. Good if you have many locks with the same key, simply
lock all the locks to one object, then lock that object to the
common key.
Example:
@lock foo=@bar locks foo to bar's key.
carry lock -- you can go though only if you carry foo.
Example:
@lock bar = +foo
Is lock -- you can only go through if you ARE foo.
Example:
@lock bar = =foo
The last two are different from @lock foo = bar in that
@lock foo =bar will let you pass either if you carry bar or are
bar.
& @name
@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.
& @newpassword
@newpassword <player> =<password>. Only wizards may use this
command. Changes <player>'s password, informing <player> that you
changed it. Must be typed in full. If you forget your password,
log on as guest (password = guest) and talk to a Wizard.
& @odescribe
@odescribe <object> [=<message>]. The odescribe message, prefixed
by the player's name, is shown to others when the player looks at
<object>. Without a message argument, it clears the message.
<object> can be specified as <name> or #<number>, or as 'me' or
'here'. May be abbreviated @odesc. See also @describe, @adescribe
and @idescribe.
& @odrop
@odrop <object> [=<message>]. The @odrop message, prefixed by the
player's name, is shown to others when the player drops <object>.
Without a message argument, it clears the message. <object> can be
specified as <name> or #<number>, or as 'me' or 'here'. See also
@drop and @adrop.
& @ofailure
@ofailure <object> [=<message>]. The @ofail message, prefixed by the
player's name, is shown to others when the player fails to use
<object>. Without a message argument, it clears the message.
<object> can be specified as <name> or #<dbref>, or as 'me' or
'here'. May be abbreviated @ofail.
See also @afail and @fail. (Note: @ofails on locked exits and
objects is considered Good Building Practice.)
& @odeath
@odeath <player> [=<message>]. The @odeath message, prefixed by the
player's name, is shown to others when the player is killed.
Without a message argument, it clears the message. <player> can be
specified as <name> or #<dbref>, or as 'me' or 'here'. See also
@adeath and @death.
& @opayment
@opayment <object> [=<message>]. The opay message, prefixed by the
object's name, is shown to others in the room with object when someone
'pays' for something. Without a message argument, it clears the message.
<player> can be specified as <name> or #<dbref>, or as 'me' or 'here'.
May be abbreviated @opay. See also @apay, @pay, and @cost.
& @open
@open <direction>[;<other direction>]* [=<number>][,<dir>[;<other dir]*].
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 Mark. If you specify <number>,
linking costs 1 more Mark. If you specify a room, you may also specify
an exit leading from that room back to the current room. This second back
exit costs the same as the forward one. See also @link and @dig.
& @osuccess
@osuccess <object> [=<message>]. The @osuccess message, prefixed by
the player's name, is shown to others when the player successfully
uses <object>. Without a message argument, it clears the @osuccess
message. It can be abbreviated @osucc. <object> can be specified as
<name> or #<number>, or as 'me' or 'here'. See also @success and
@asuccess. (Putting @osuccs on all useable exits and takeable
objects is considered Good Building Practice, especially if it
allows people to follow people w/o shouting out which exit to take
each time you leave a room.)
& @ouse
@ouse <object> [=<message>]. The @use message, prefixed by the player's
name, is shown to others when a player successfully does a "use" on
the object. Without a message argument, it clears the @ouse message.
See also @use and @ause.
& @password
@password <old password>=<new password>. This changes your
password. It can be abbreviated @pass.
& @payment
@payment <object> [=<message>]. The pay message is shown to the player
who paid the object. Without a message argument, it clears the message.
<player> can be specified as <name> or #<number>, or as 'me' or 'here'.
May be abbreviated @pay. See also @apay, @opay, and @cost.
& @pemit
@pemit <object> = <message> sends message to object directly.
It is very similar in its effects to @emit except only one object
will see the message. You may @pemit to objects in the same room,
objects you are carrying, and to objects that are carrying you,
or @pemit remotely, using #<object> or *<player name>.
See also @emit, @oemit, @remit, NOSPOOF, and SPOOFING.
& pose
pose <action pose>. Displays your name followed by the statement
you posed. May be abbreviated by the ':' symbol. Example:
If you are player Bob, and you type in ':laughs out loud'
everybody in the room will see:
Bob laughs out loud
& @runout
@runout <object> = <actions> This is an action to be taken when
charges reach zero (See '@charges'). Actions are lists of commands
separated by semi-colons, and these commands are executed by the
object (see puppet). Things can execute almost any command but
rooms and exits are restricted to forcing puppets to do things.
Gender substitutions are applied to the commands before they are
executed, this allows use of the players name who caused the
action.
& @search
@search [<player>] [<class>=<restriction>]. This command searches
the database and lists objects which meet user specified search
criteria. If a <player> argument is supplied, only objects owned
by that player will be listed. If a <class> argument is supplied
only objects of a certain class will be listed. Possible <class>es
include (TYPE, NAME, ZONE, EXITS, OBJECTS, ROOMS, PLAYERS, and FLAGS).
If <class>=TYPE, possible <restriction>s include (OBJECTS, ROOMS,
EXITS, PLAYERS). If <class>=NAME, only objects whose name begin
with the string <restriction> will be listed. If <class>=ZONE, only
objects in the zone <restriction> will be listed. The <restriction>
must be specified as a dbref number. If <class>=EXITS, OBJECTS, ROOMS,
or PLAYERS, only objects of that type and whose name begin with the
string <restriction> will be listed. Finally if <class>=FLAGS, only
objects with the list of flags specified by <restriction> will be listed.
For the class TYPE=PLAYER, and for PLAYER=<player-name>, anyone may
obtain information on any player. In all other cases, only wizards may
obtain information about other players. This is computationally
expensive, costing 100 pennies. It is generally faster than @find.
Examples:
@search flags=Wc <-- search for connected wizards.
@search type=rooms <-- list all rooms owned by me.
@search zone=#50 <-- list all objects belong to zone #50.
& @set
@set <object>=<flag>; @set <object>=!<flag>;
@set <object>=<attribute>:<value> or a shorthand version may be
used
@<attribute> <object>=<value> Sets (or, with '!', unsets) <flag> on
<object>.
See FLAGS.
& @sex
@sex <player> = <gender> Used for pronoun substitution, normally
male or female. Visible to all. Examples:
@sex me = Male
@sex me = No thank you (silly, but possible)
& @shutdown
@shutdown. Only wizards may use this command. Shuts down the game.
Must be typed in full.
& @startup
@startup = <action list>. This is an action list that gets
triggered the first time the mud comes up. If the mud crashes,
this list will be triggered when the mud comes back up. Thus, you
can retrigger objects that need to be running continuously.
& @stats
@stats. Display the number of objects in the game broken down by
object types. Wizards can supply a player name to count only
objects owned by that player.
& @success
@success <object> [=<message>]. Sets the success message for
<object>. The message is displayed when a player successfully uses
<object>. Without a message argument, it clears the message. It
can be abbreviated @succ. <object> can be specified as <name> or
#<dbref>, or as 'me' or 'here'. See also @osuccess and @asuccess.
& @use
@use <object> [=<message>]. Sets the use message for <object>. The
message is displayed when a player successfully does a "use" on the
object. Without a message argument, it clears the message.
& @teleport
@teleport [<object>=] <room>. Teleports <object> to <room>.
<object> must be a thing. (Wizards can also teleport players.) You
must be able to link to the destination, and either control the
object or its current location. You can only teleport objects into
a rooms and objects you own only. If the target room has a drop-to,
<object> will go to the drop-to room instead. Wizards can teleport
things into players' inventories.
& @unlink
@unlink <dir>; @unlink here. Removes the link on the exit in the
specified direction, or removes the drop-to on the room. Unlinked
exits may be picked up and dropped elsewhere. Be careful, anyone
can relink an unlinked exit, becoming its new owner (but you will
be reimbursed your 1 Mark). See @link.
& @unlock
@unlock <object>. Removes the lock on <object>. See @lock.
& @wall
@wall <message>. Only wizards may use this command.
Shouts <message> to every player connected. Must be typed in full.
& @rwall
@rwall <message>
Only wizards and royalty may use this command. It broadcasts a message to
all connected wizards and royals, prefixed with "Admin:". If the first
character is : or ; it does the same thing as @wizpose.
& @rwallpose
@rwallpose <pose>
Only wizards and royalty may use this command. It's a variant of @rwall,
using a pose, and is identical to "@rwall :<pose>"
& @rwallemit
@rwallemit <message>
Only wizards and royalty may use this command. It is similar to @wizemit,
but broadcasts the message to all connected wizards and royals.
& @wizwall
@wizwall <message>. Only wizards may use this command.
Shouts <message> to all wizards logged in. If the first character is
a : or ; it does the same thing as @wizpose. (; doesn't attach the space)
& @wizpose
@wizpose <message>. Only wizards may use this command.
Shows the <message> to all wizards logged on in pose format.
& @wizemit
@wizemit <message>. Only wizards may use this command.
Shows <message> to all wizards logged on in emit format.
& @whereis
@whereis <player>. Tells you the location of the player. If you
wish to remain unlocatable, set your UNFINDABLE flag. (See FLAGS).
The person being located will get a message to inform them that you
have successfully or unsuccessfully located them.
Ex: @whereis Moonchilde
& ATTRIBUTES
ATTRIBUTES
The following standard attributes can be set on your character.
These attributes are set by typing @<attribute> <object> = <value>.
Typing help on the @-command associated with each attribute will get
you help on that attribute. Attributes with (*) after them are special,
and a) cannot be set by players and b) are possibly only visible to
wizards. There is a section also on NON-STANDARD ATTRIBUTES.
AAHEAR ACLONE ACONNECT ADEATH ADESCRIBE
ADISCONNECT ADROP AEFAIL AENTER AFAILURE
AHEAR ALEAVE AMHEAR AMOVE APAYMENT
ASUCCESS AWAY CHARGES COST DEATH
DESCRIBE DOES DROP EALIAS EFAIL
ENTER FAILURE HAVEN IDESCRIBE IDLE
LALIAS LAST (*) LASTSITE (*) LEAVE LISTEN
MOVE ODEATH ODESCRIBE ODROP OEFAIL
OENTER OFAILURE OLEAVE OMOVE OPAYMENT
OSUCCESS OXENTER OXLEAVE PAYMENT PASSWORD (*)
QUEUE (*) RQUOTA (*) RUNOUT SEX STARTUP
SUCCESS
Those with a (*) above have a separate help section for each of them
so that you can find out what each attribute controls.
Any attribute name can be shortened, but at shorter forms run the risk
of conflicting with other attribute names. This could result in you
setting an unwanted attribute.
& LAST
LAST
This attribute shows the last time you connected to the MUSH. It is
only visible to objects that control you (wizards, you or your objects)
or if you set yourself VISUAL.
& PASSWORD
PASSWORD
This attribute stores your encrypted password. It is not visible to
anyone within the game, and cannot be altered except via the @password
and @newpassword commands.
& QUEUE
QUEUE
This attribute is only visible to objects that control you (wizards,
yourself, and your objects) or unless you are VISUAL. It tracks how
many active commands you have in the queue.
& RQUOTA
RQUOTA
This attribute tracks building quota if it is implemented. It is
settable in-game only by a wizard, and is only visible to wizards.
& NON-STANDARD ATTRIBUTES
NON-STANDARD ATTRIBUTES
Objects now have the capability of having an unlimited number of
attributes. These attributes can have any name. In order to preserve
backward compatibility, the VA-VZ, WA-WZ, and XA-XZ attributes still
exist in their previous form, and are set like a normal attribute.
To set a new style attribute, you use the form
@_<attribute_name> <obj> = <value> OR
@set <obj> = <attribute_name>:<value>
All attributes have the ability to be used in attribute locks (see help
@lock). Attributes also have the new ability to be 'owned' independent
of object ownership (see help ATTRIB-OWNERSHIP). All attributes
can be addressed in get() as well as in edit, and %-substitute form,
as well as accessed via the V-function.
& ATTRIB-OWNERSHIP
ATTRIBUTE OWNERSHIP
The first person to create an attribute on an object is said to 'own'
that attribute. You must control the object in order to create an
attribute on it. ***OWNERSHIP OF ATTRIBUTES IS NOT CHANGED WHEN AN
OBJECT IS @CHOWNED*** This allows for 'locks' which cannot be faked
as the person who controls the lock and the person who controls the
attribute MUST be the same for the lock to succeed. It is also
possible to 'freeze' or 'lock' an attribute so that new owners of the
object can not tamper with it. This allows 'standard' commands on
objects and other neat stuff. Attribute locking is controlled by the
new command @atrlock and attribute ownership can be changed via the
@atrchown command.
& BEING KILLED
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 Marks in insurance money (unless you have >= 10000
Marks or you were killed via the Wizard slay command). See MONEY.
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.)
& BOGUS COMMANDS
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=me&!me"
(impossible to be both at once, therefore 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.
A better way to do user-defined commands is to use $comands on objects.
These are set using &<attrib> <object>=$<command pattern>:<actions>
If something a user types matches the command pattern, the actions are
executed. In order to execute a $command, you must pass the object's
uselock. Otherwise, you will get a "Permission denied." message.
& CONTROL
CONTROL
There are 3 rules to controlling objects:
1) You control anything you own.
2) A wizard controls everything.
3) Anybody controls an unlinked exit, even if it is locked.
Builders should beware of 3, lest their exits be linked or stolen.
& COSTS
COSTS
kill: 10 Marks (or more, up to 100 Marks)
page: 1 Mark
@dig: 10 Marks
@create: 10 Marks (or more, up to 505M),
(sacrifice value=(cost/5)-1.)
@find: 300 Marks
@search: 300 Marks
@entrances: 300 Marks
@link: 1 Mark (if you didn't already own it,
+1 to the previous owner).
@open: 1 Mark (2 Marks if linked at the same time)
& DROP-TO
DROP-TO
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.
& EXITS
EXITS
An exit links one room to another room. If an exit is set DARK it will
not show up in the list of obvious exits in a room.
& FAILURE
FAILURE
You fail to use a thing when you cannot take it (because its lock
fails). You fail to use an exit when you cannot go through it
(because it's unlinked or locked). You fail to use a person when
you fail to rob them, but you can't rob in a mush. You fail to use
a room when you fail to look around (because it's locked).
See ATTRIBUTES, @fail and @ofail.
& FLAGS
FLAGS
@set <object> = <Flags> to set, @set <object> = !<Flag> to
reset. Everything in the universe of this MUSH (Rooms, Exits,
Objects, Players, etc...) are represented in the same way at the
program level. A room merely has the room flags set and a player
has the player flags 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.
For more specific information on a particular flag, request help on
a flag title.
Example: help ENTER_OK
** To get the list of flags, do help flags-list
& FLAGS-LIST
Flag Title Flag Title Flag Title
---------------------------------------------------------------------
A - ABODE flag B - BUILDER flag C - CHOWN_OK flag
D - DARK flag E - EXIT flag F - FLOATING flag
G - GOING flag H - HAVEN flag I - INHERIT flag
J - JUMP_OK flag K - KEY flag L - LINK_OK flag
N - NOSPOOF flag O - OPAQUE flag P - PLAYER flag
Q - QUIET flag R - ROOM flag S - STICKY flag
T - TEMPLE flag U - UNFINDABLE flag V - VISUAL flag
W - WIZARD flag X - SAFE flag
c - CONNECTED flag d - DESTROY_OK flag e - ENTER_OK flag
g - GAGGED flag h - HALT flag i - IMMORTAL flag
n - NO_TEL flag p - PUPPET flag r - ROYALTY flag
t - TRANSPARENT flag u - SUSPECT flag v - VERBOSE flag
x - TERSE flag
---------------------------------------------------------------------
& INHERIT
Inherit is a security flag used to prevent objects without authorization
from using @force, @set, and @trigger on other objects.
Authorization is successful if:
1. The enactor is WIZARD.
2. The enactor's owner is INHERIT.
2. The enactor is INHERIT.
3. The target is not INHERIT.
Only INHERIT or WIZARD objects may force their owners. Players can
always @force, @set, and @trigger their objects.
Authorization is only denied if the enactor is neither a player nor
INHERIT, and the target is WIZARD or INHERIT.
Objects which are WIZARD are not subject to any special criterion,
although they are automatically considered to be INHERIT.
The normal criteria for object control still apply.
& VERBOSE
An object set VERBOSE echoes the commands it executes to its owner
before executing them. This differs from the PUPPET flag in that the
owner sees the command itself, rather than the output from the command.
This flag is extremely useful in debugging, especially if used in
conjunction with the PUPPET flag. VERBOSE output follows the format
"#<object>] <command>". Something like "#1300] @trigger me/va" is a
good example of typical VERBOSE output.
& TERSE
TERSE
When an object is set TERSE, it does not see the descriptions or
success/failure messages in rooms. This is a useful flag if you're
on a slow connection or you're moving through a familiar area and
don't want to see tons of text.
& SUSPECT
SUSPECT
This flag is only settable by wizards. Players with this flag have
their connects, disconnects, name changes, and kills reported to
all connected wizards.
& SAFE
SAFE
This flag, when set on an object, prevents the object from being
destroyed via the @destroy command. The "@nuke" command must be
used to recycle the object. Valuable objects should be protected
by this flag.
& NO_TEL
NO_TEL
The @teleport command may not be used by mortals in a room that has
this flag set. Puzzle rooms, prisons, and similar locations would
probably benefit from this flag.
& IMMORTAL
IMMORTAL
If this flag, which is settable only by wizards, is set on an object,
that object may not be killed by mortals. This is useful for machines
which need to run continuously.
& ROYALTY
ROYALTY
If this flag is set on any type of object, then that object will
be able to @tel and examine as if it was a wizard. It will not however be
able to change things like a wizard could. Only wizards may set it on
players, although players who are ROYALTY may set their objects ROYALTY.
& TRANSPARENT
TRANSPARENT
If this flag is set on an exit, when a player looks at the exit they
will see the description and contents of the destination room following
the exit's description. The exit list and succ/fail messages of the
room will NOT be displayed.
& ABODE
ABODE If a room is set ABODE, any player can set his home 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. This flag should not be set unless you want to make the
room a public 'living area'.
& 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. If your god wishes it so, objects and wizards
that are dark will be slightly disguised in speech and poses. Such
actions by these objects will show as being from Someone or Something
depending on whether it was an object or wizard.
& 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>.
Only objects which are ENTER_OK may be entered, regardless of the
enter lock. Players must also have the ENTER_OK set if they wish to
be able to receive things given to them by other players via the
'give <player> = <object>'.
& GENDER
GENDER @set me=sex:<unassigned|male|female|neuter>. Default
unassigned. If a player's gender is set, %-substitutions will use
the appropriate pronoun for that player. Only meaningful for
players.
See SUBSTITUTIONS.
& 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.
When it is set on an exit, it prevents puppets from going through it.
& 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. 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.
& 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.
& HALT
HALT 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 Marks 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.
& 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.
& NOSPOOF
NOSPOOF If an object is set NOSPOOF, @emits, @oemits, @remits and
@pemits will be distinctively tagged to help prevent spoofing.
See SPOOFING, @emit, @pemit, @remit, and @oemit.
& LISTENING
There 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. This takes the form of:
&<attribute> <object> = ^<pattern>:<action>
The criterion for triggering a pattern-listen is the same as that for
triggering an @ahear - the object cannot trigger its own listen patterns.
Example:
> &TEST object = ^* screams.:"Hello, %0.
Object - Set.
> :screams.
Amberyl screams.
> Object says "Hello, Amberyl."
& HERE
HERE The word 'here' refers to the room you are in. For example,
to rename the room you're in (if you control it), you could enter
"@name here= <new name>".
& HOMES
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 (See STICKY). 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 their inventory) by
"@link <dir>=home". Drop-tos can also be set to 'home'.
See DROP-TO and @link.
& LINKING
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 can set
the destination of exits to that room if it is LINK_OK.
See LINK_OK, ABODE and @link.
& ME
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
You will be given a daily allowance of Marks to spend in anything
you can find to spend it on. See COSTS and SACRIFICING.
& PUPPETS
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 Marks
they are also taken from and given to its master. In order to
prevent puppets from screwing up puzzles objects may have the key
flag set, which 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,
[name/# of puppet] command
example:
@force fred="hi there. or
fred "hi there. or
#4342 "hi there.
& ROBBERY
ROBBERY Robbing is not allowed on this MUSH. If you really
need money, ask your friendly neighborhood wizard. (Like Leona, who
is *really* friendly. Give her a page hi!)
& SACRIFICING
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
>= 10000 Marks, all sacrifices are worth only 1 Marks. The
sacrifice value of a thing is set at creation by
"@create frob=cost", by the formula value=(cost/5)-1. Only a wizard
can change the value of an object, once created.
& SUBSTITUTIONS
SUBSTITUTIONS All messages may contain %-substitutions, which
evaluate to gender-specific pronouns if the player's gender is set.
They are:
%s (subjective) = Name, he, she, it.
%o (objective) = Name, him, her, it.
%p (possessive) = Name's, his, her, its.
%N (player's name) = Name.
If you need a '%', use %%.
Ex. '@ofail teapot=burns %p hand on the hot teapot.'
See GENDER.
Other substitutions, such as %va-%vz, %wa-%wz, %xa-%xz, and %0-%9
may also be used and will be evaluated to v(?) (See V-FUNCTIONS)
where ? is a-z or 0-9. In these substitutions and pronoun substituions,
if the first letter of the name is capitalized, the first letter of
the substitution will also be capitalized.
Other possible substitutions are:
%# (player number) = #<actor's number>. Equivalent to num(%N)
%! (object number) = #<message holder's number>. Equivalent to num(me)
%r (newline) = New line character in output.
%t (tab) = Tab character in output.
%b (blank) = Space in output.
%_<attrname> This will give you the discreet value of ANY attribute you can
read on the object.
& SUCCESS
SUCCESS You successfully use an object when you take it. You use
an exit successfully when you go through it. You successfully use
a room when you look around. See ATTRIBUTES, @SUCCESS and @OSUCCESS.
& TYPES OF OBJECTS
TYPES OF OBJECTS 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.
& ENACTOR
The enactor is the thing that is doing something. If one of your
Objects does something (through a @force or @trigger) it is the
enactor. If one of your links or rooms does something (through a
@Asuc, @Afail or @Aenter) then YOU are the enactor and the action
happens as if you typed it in directly. To determine the enactor
create an object to listen for the action with @ahear = :[v(N)].
& STACK
V(0) through V(9) are the ten items on the stack. Stack values can
be set by either parameters after an @trigger or asterisk substitution
in pattern matching.
Example: @listen item=* foo *; @ahear item= [v(1)] bar [v(0)].
& @switch
The @switch is the general for/while/until/if part of MUSH. The
format is:
@switch thing= pat1, action1, pat2, action2, ...default-action
Example: @switch [rand(2)]=0,:foo,:bar
& @trigger
@trigger can pass control and data (on the stack) between or within
items.
Example: @va item=@trigger me/vb=[v(0)]; @vb item = :[v(0)];
@trigger item/va=foo.
& VERBS
For most verbs there are three forms: Verb (what the Enactor sees),
Overb (what others in the area see) and Averb (the action to be
taken when the event happens). Example: @Drop, @Odrop and @Adrop
& V-function
The V function has many forms: v(N) {The enactor}, v(#)
{the number of the enactor}, v(vq) {@VQ of the current object},
v(0) {The top item on the stack}, etc. Example, try: :[v(N)]
& @sweep
@sweep [connected]
@sweep gives you a list of all objects/players 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 and puppets since they will
hear everything you say and do. (And might post the same to r.g.m!)
If the connected flag is given, only connected players and puppets
owned by connected players will be shown in the @sweep.
& 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) See also @emit, @pemit, @remit, @oemit and NOSPOOF.
& 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.
The functions available in the MUSH code are:
ADD() AND() ALPHAMIN() ALPHAMAX()
ART() CAPSTR() CAT() COMP()
CON() DIST2D() DIST3D() DIV()
ELOCK() EQ() EXIT() EXTRACT()
FIRST() FLAGS() FLIP() GET()
GT() GTE() HASFLAG() HOME()
LCON() LCSTR() LEXITS() LNUM()
LOC() LOCK() LSEARCH() LT()
LTE() LWHO() MAIL() MATCH()
MAX() MEMBER() MID() MIN()
MOD() MONEY() MUL() NAME()
NEARBY() NEQ() NEXT() NOT()
NUM() OBJ() OR() OWNER()
POS() POSS() RAND() REMOVE()
REST() RNUM() S-Function SORT()
STRLEN() SUB() SUBJ() TIME()
TYPE() UCSTR() V-Function WORDPOS()
WORDS() XGET() XOR() ZONE()
NOTE: %-substitutions do not always work as arguments for functions.
& HOME()
home(<object>)
Returns the object's 'home'. This is the home for players, or the
drop-to for rooms.
& ZONE()
zone(<object>)
Returns the object's 'zone'. This is the dbref of the master object
which defines the zone.
& LSEARCH()
lsearch(<player>, <class>, <restriction>)
This function is similar to the @search command, except it returns
just a list of dbref numbers. It is computationally expensive, and
costs 100 pennies to perform.
The function must have three arguments. Wizards can specify "all"
or <player> for the <player> field; mortals must use "me".
If you do not want to restrict something, use "none" for <class>
and/or <restriction>.
Possible <class>es are TYPE, NAME, ZONE, EXITS, OBJECTS, ROOMS,
PLAYERS, and FLAGS. If <class>=TYPE, the possible <restrict>ions
are OBJECTS, ROOMS, EXITS, and PLAYERS. If <class>=NAME, only
objects with <restriction> whose name matches <restriction> will
be listed. If <class>=EXITS, OBJECTS, ROOMS, or PLAYERS, only
objects of that type and whose name matches <restriction> will
be listed. If <class>=ZONE, only objects belonging to the zone
<restriction> will be listed. <restriction> must be specified
as a dbref number. If <class>=FLAGS, only objects with the list
of flags specified by <restriction> will be listed. Only wizards
may obtain information about other players.
Examples:
lsearch(all, flags, Wc) <-- lists all connected wizards.
lsearch(me, type, rooms) <-- lists all rooms owned by me.
& ALPHAMIN()
alphamin(<word1>, <word2>, <word3>, ...)
Takes up to ten word arguments, and returns the word which is
lexicographically smallest.
& ALPHAMAX()
alphamax(<word1>, <word2>, <word3>, ...)
Takes up to ten word arguments, and returns the word which is
lexicographically biggest.
& SORT()
sort(<word1>, <word2>, <word3>, ...)
Takes up to ten word arguments, and sorts them into lexicographic
order. It returns a space-separated list of words.
& SUBJ()
subj(<object>)
Returns the subjective pronoun - he/she/it - for an object.
& OBJ()
obj(<object>)
Returns the objective pronoun - him/her/it - for an object.
& POSS()
poss(<object>)
Returns the possessive pronoun - his/her/its - for an object.
& TYPE()
type(<object>)
This function returns the type of an object - PLAYER, THING, EXIT,
or ROOM. See "help types of objects" for more.
& RNUM()
rnum(<room number>, <object>)
This function returns the dbref number of an object (player, thing, or
exit). The object must be in the specified room. This function is
essentially identical to NUM(), except it matches things in the
specified room rather than the room that you are in. The RNUM()
function is meant to be used in conjunction with Master Room objects.
& MAX()
max(<num1>, <num2>, ..., ...)
This function returns the largest number in its list of arguments.
It can take up to ten numbers as arguments.
& MIN()
min(<num1>, <num2>, ..., ...)
This function returns the smallest number in its list of arguments.
It can take up to ten numbers as arguments.
& MAIL()
mail(<mail message #>)
This function returns a message corresponding to that mail message
number in your MUSH mailbox. This function can be used to forward
mail, or as a way to simply transfer mail messages to attributes
on an object.
& XGET()
xget(<object>, <attribute>)
This function is identical to get() in purpose, but a comma instead of
a slash separates object and attribute. Unlike get(), xget() allows
nesting of functions, and multiple nested xgets. Please see "help get()"
for more details on the use of this function.
& ART()
art(<string>)
This function returns the proper article, "a" or "an", based on whether
or not <string> begins with a vowel.
& LWHO()
lwho()
This returns a list of the dbref numbers for all currently-connected
players. Only wizards may use this function; it returns "#-1" otherwise.
& HASFLAG()
hasflag(<object>, <flag name>)
Returns 1 if the object has the named flag, and 0 if it does not.
You do not have to control the object.
Example: hasflag(me, connected) will return "1"
& DIST2D()
dist2d(x1, y1, x2, y2)
Returns the integer distance between two points in the Cartesian
plane that have coordinates (x1, y1) and (x2, y2).
& DIST3D()
dist3d(x1, y1, z1, x2, y2, z2)
Returns the integer distance between three points in space, with
coordinates (x1, y1, z1) and (x2, y2, z2).
& WORDPOS()
wordpos(<string>, <number>)
Returns the number of the word within <string> where the <number>th
character falls. Characters and words are numbered starting with 1,
and spaces between words are treated as belonging to the word that
follows them. If <number> is not within the string, #-1 is returned.
Example: wordpos(foo bar baz, 5) returns "2"
& LCSTR()
lcstr(<string>)
Returns <string> with all letters converted to lowercase.
Example: lcstr(Foo BAR bAz) returns "foo bar baz"
& UCSTR()
ucstr(<string>)
Returns <string> with all letters converted to uppercase.
Example: ucstr(Foo BAR baz) returns "FOO BAR BAZ"
& CAPSTR()
capstr(<string>)
Returns <string> with the first character capitalized.
Example: capstr(foo bar baz) returns "Foo bar baz"
& NEARBY()
nearby(<object 1>, <object 2>)
Returns 1 if object 1 is "nearby" object 2. "Nearby" is defined as:
object 1 is in the same location as object 2, or,
object 1 is being carried by object 2, or,
object 1 is carrying object 2.
You must control at least one of the objects.
& FLIP()
flip(<string>)
This function reverses a string. For example, "flip(foo bar baz)"
returns "zab rab oof".
& MONEY()
money(<object>)
returns the amount of money <object> has.
& LCON()
lcon(<object>)
returns a list of the dbrefs of all contents in a room that you can
see.
& LEXITS()
lexits(<object>)
returns a list of the dbrefs of all the non-dark exits in the current
room.
& WORDS()
words(<string>)
words() returns the number of words in a string.
& SUB()
sub(<num>, <num>)
Sub() returns the integer subtraction of two numbers.
& LOCK()
lock(<object>)
lock() returns the text string equivalent of the lock on an object that
you control.
& ELOCK()
elock(<object>, <victim>)
elock() returns 1 if the <victim> would pass the lock on <object>,
and 0 if it would fail. You do not need to control either object.
& GET()
get(<object>/<attribute>)
The get function will be replaced by the string stored in the
attribute of the object. You may get the attributes of objects you
control, the attributes you control on other objects, and publicly
accessible attributes.
Note: The substitutions %va for [get(me/va)], %vb for [get(me/vb)]
are legal, assuming it's not in a compound expression.
[first(rest(%va))] would not work where [first(rest(get(me/va)))]
would.
& TIME()
time()
Gives you the current time on the MUSH.
WARNING! This is the time on the machine that the mud is running
on, and not where you are.
& RAND()
rand(<num>)
Rand returns an interger between 0 and num-1.
& EXIT()
exit(<object>)
Exit returns the first exit on the list of exits in the object.
Dark exits are not listed. See Next for the method for seeing the
rest of the exits in an object.
& ADD()
add(<number>,<number>)
Add returns the integer sum of the two numbers.
& MUL()
mul(<number>,<number>)
Mul returns the integer multiple of the two numbers.
& DIV()
div(<number>,<number>)
Div returns the integer quotient of the first number divided by
the second number. See MOD.
& MOD()
mod(<number>,<number>)
Mod returns the remainder of the interger division of the first
number by the second. See DIV.
& LNUM()
lnum(<number>)
Lnum returns a list of numbers, from 0 to <number - 1>. For example,
lnum(4) returns the list "0 1 2 3". This is useful for creating loops.
& FIRST()
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. See REST.
& REST()
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.
See FIRST.
& STRLEN()
strlen(<string>)
Returns the length of the string in a numerical string.
& 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 first 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 string2, and -1
otherwise.
& S-FUNCTION
s(string)
This function performs pronoun substitution in a string, and then
returns that string. As usual, %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.
& MATCH()
match(<string>, <pattern>)
This function tests if the pattern matches 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.
& 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.
& NUM()
num(<object>)
Returns the dbref number of the object, which must be in the same
room as the object executing num.
& 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()
loc(<object>)
Loc returns the dbref of the location that object is at. The
object has to either be yours or be in the same room as you to
work.
& 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.
& @ps
@ps is a useful command for mushers. It lists all commands
currently on your 'to be executed' queue, thus allowing you to
identify infinite (or unnecessary) loops with-out putting in says
or poses. It gives a count of the total commands in each of the
queues (Player, Object, and Wait), displayed in the format
<Number of your queued commands> / <Total number of queued commands>.
@ps can identify that you actually *do* have an infinite loop. Much
better than waking up in the morning with all your money gone!
@ps for wizards now works as follows. @ps with no arguments will
show you your own queue. "@ps all" will show you the full queue.
"@ps <*player>" will show you that player's queue. "@ps count"
just displays the count totals.
& Looping
Looping in an object can have it's good parts and it's bad parts.
The good part is when you activate part of a program multiple times
to exhaustively perform an operation. This is usually done by:
va: <list of commands>;@trigger me/vb
vb: @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'd will drain your marks while you are away
from the mush!
See @ps.
& enter
enter <object> can be used to enter the inside of an object.
Insides of objects are best used for vehicles, or storage spaces
when you don't have a home. (or even a floating home) Note that
you can enter only objects you own or that have the Enter_ok flag
set.
(see @enter, @oenter, @aenter, leave, @lock, and @idesc)
& @enter
@enter <object> = <message>
Basically the @succ for the 'enter <object>' exit. The message is
displayed to anyone entering the object.
& @leave
@leave <object> = <message>
Basically the @succ for the 'leave <object>' exit. The message is
displayed to anyone leaving the object.
& @oenter
@oenter <object> = <message>
Similarly to other omessages, this displays <name> <message> to
everyone inside the object, except for the person who is entering.
& @oleave
@oleave <object> = <message>
Similarly to other omessages, this displays <name> <message> to
everyone inside the object, except for the person who is leaving.
& @aenter
@aenter <object> = <actionlist>
Executes <actionlist> whenever someone enters the object. Actions
are lists of commands separated by semi-colons and these commands
are executed by the object (see puppet). Objects can execute almost
any command. Gender substitutions are applied to the commands
before they are executed, which allows use of the player's name who
caused the action. See @enter, and @oenter.
& @aleave
@aleave <object> = <actionlist>
Executes <actionlist> whenever someone leaves the object. Actions
are lists of commands separated by semi-colons and these commands
are executed by the object. (see puppet). Objects can execute almost
any command. Gender substitutions are are applied to the commands
before they are executed, which allows use of the player's name who
cause the action. See @leave and @oleave.
& @oxenter
@oxenter <object> = <message>
This replaces the functionality of the old @oenter. This message is
shown to everyone in the room that the player leaves whenever he enters
an object via the command 'enter <object>'. This will be shown in
addition to the leave message of the room, not instead of.
& @oxleave
@oxleave <object> = <message>
This message is shown to everyone in the room that a person enters
when doing a 'leave' command. This will be shown in addition to the
enter messages of the room, not instead of.
& 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.)
& 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()
[gt(<integer1>,<integer2>)]
Takes two integers, and returns 1 if and only if
integer1 > integer2, and 0 otherwise.
& gte()
[gte(<integer1>,<integer2>)]
Takes two integers, and returns 1 if and only if
integer1 >= integer2, and 0 otherwise.
& lt()
[lt(<integer1>,<integer2>)]
Takes two integers, and returns 1 if and only if
integer1 < integer2, and 0 otherwise.
& lte()
[lte(<integer1>,<integer2>)]
Takes two integers, and returns 1 if and only if
integer1 <= integer2, and 0 otherwise.
& eq()
[eq(<integer1>,<integer2>)]
Takes two integers, and returns 1 if they
are equal, 0 otherwise.
& neq()
[neq(<integer1>,<integer2>)]
Basically the same as [not(eq(<integer1>,<integer2>))].
(see eq(), not())
& cat()
[cat(<string1>,<string2>)]
Cat returns a string made up of the contents of
string1 followed by the contents of string2, separated by a space.
So [cat(one, two)] will return 'one two'.
& member()
[member(<list>,<word>)]
Member takes a list and a word, and returns the position of <word>
if <word> is a word in <list>. A word is defined as a string which
has no interior spaces. So ' hello ' would be one word, while
'hello there' would be two. See LISTS
& LISTS
A list is a string, usually stored in an attribute (currently any
of the va-vz's), which is a series of words, separated 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(), remove(), all work
on lists. Look them up, they can be very helpful.
& leave
The command leave allows you to exit an object you have enter'ed
into. There is not way to stop someone from leaving an object once
they get inside it, and there is not any oenter or enter messages
that get triggered.
See enter, enter_ok.
& remove()
[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.
& RWHO
RWHO This MUSH may be attached to the RWHO server that was created
by Marcus Ranum (Jerry_Cornelius). Every so often, the MUSH sends
out information about who is logged in to this server. The RWHO
command is an internal client that talks to this server. Most MUSHes
might not have this command even if they actually send information to
an RWHO server. The reason that PernMUSH has this in-game is because
there is also an RWHO server on the same machine. If it was on a
separate machine, network problems could freeze the mud.
& @remit
@remit <object> = <message>. Sends the message to all contents of
<object>. See also @emit, @pemit, @oemit, SPOOFING, NOSPOOF and CONTROL.
& @oemit
@oemit <object> = <message>. Sends <message> to all contents of your
current location EXCEPT object. See also @emit, @pemit, NOSPOOF and
SPOOFING.
& @halt
@halt <object> or @halt <player>=<new_command>
The first form is an alias for "@set <object>=HALT".
The second form removes all queued actions in all queues for all of
a player's objects. <new_command> is placed in the queue after the
previous commands have been removed. If you want to clear your own
queue, use "@halt me".
& @allhalt
@allhalt. This commands halts all objects in the game in an effort to
free up the queue. This is a wizard only command.
& @chownall
@chownall <player> [= <target_player>]. Tranfers ownership of all items
that player owns (except player) to the ownership of target_player.
This is a wizard only command. If target_player is not given, the
executing recipient is the subject of the @chownall.
& @doing
@doing <message>. If this is compiled in you can set a short message that
will show up in the WHO listing next to your name.
& @motd
@motd <message>. This is a wizard only command that will set a short
(non-longterm) message that will be shown to players when they connect.
& @wizmotd
@wizmotd <message>. This is a wizard only command that will set a short
(non-longterm) message that will be shown to wizards when they connect.
& @rejectmotd
@rejectmotd <message>. This is a wizard only command that will set a
short (non-longterm) message that will be shown to players that try to
connect when logins are disabled.
& @listmotd
@listmotd. This is a wizard only command that will display the current
motd, wizmotd and rejectmotd to the player.
& @poor
@poor <value>.
This is a wizard only command. It sets every player's money supply to
value.
& @entrances
@entrances <object>.
This command will show you all exits linked to the object you use the
command on, as well as where the exit originates. This command
currently costs 300 Marks.
& @login
@login [on|off].
This is a wizard only command that will enable or disable non-wizard
logins to the mush.
& @atrlock
@atrlock <object>/<attribute> = [on|off].
If 'on' is specified, it 'locks' the specified attribute on the object
if it is unlocked already. If the attribute is unlocked, and owned by
someone other than you, you will gain ownership of it. If an attribute
is unlocked, then anyone who controls the object or the person who
controls the attribute may change it. Wizards may lock/unlock anyones
attributes (but will not transfer ownership). If you specify 'off' it
will unlock a locked attribute. Specifying neither will return the
current value of the lock.
& @atrchown
@atrchown <object>/<attribute> = <new_owner>.
Like @chown except it changes the control of an attribute from one person
to another.. You may only @atrchown attributes that you currently own.
& @allquota
@allquota <limit>
This is a wizard level command that is only available if the quota
system is being used. It displays the current max and owned objects
of every player and resets their quota left to the new limit minus the
current number owned.
& @dbck
@dbck
This is a wizard only command. It forces the database to do run
the internal cleanup and consistency check that normally runs about
every 10 minutes or so. (This command implies @purge)
& @dump
@dump
This is a wizard only command that saves a copy of the current memory
database out to a save file. This preempts the normal regular dumping
that the mud performs on it's own.
& @pcreate
@pcreate <name> = <password>
This is a wizard level command that is only available if registration is
being enforced. It creates a player with the given name and password.
& @purge
@purge
This is a wizard only command that will check the destroyed object list
for corruption, and make sure that all objects there are really there.
& @quota
@quota <victim>
This is a wizard level command that is only available if the quota
system is enabled. It reports the victim's owned objects and the
maximum number of objects he may own.
& @squota
@squota <victim> = <limit>
This is a wizard level command that is only available if the quota
system is enabled. It reports the victim's owned objects, and sets
the maximum number of objects he may own to <limit>. If no limit is
specified, this works identically to @quota.
& @toad
@toad <player>
This is a wizard only command. It changes a player into an object, and
@chowns all of the previous players possessions over to the @toading
wizard.
& @version
@version
Tells the player which version of the code is currently running on the
system.
& @wait
@wait <time> = <command_list>
Puts the command list (a semicolon separated list of commands) into the
wait queue to execute in <time> seconds.
& @gedit
@gedit <object>/<pattern> = <string1>, <string2> This command will
perform an @edit on every attribute of <object> that matches <pattern>.
Patterns are any wildcarded string (* or ?) where *s match 0 or more
characters and ?s match exactly one character.
& @adisconnect
@adisconnect <object> = <command-list>
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.
& @aconnect
@aconnect <object> = <command-list>
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 = :stretches luxuriously, as if waking from a nap.
See also: @adisconnect.
& @lemit
@lemit <message>
Emits a message to the outermost container object. For example, if you
are carrying a bird, and are inside a vehicle which is in room #10, and
you force the bird to @lemit "Cheep", everyone in room #10 will hear
"Cheep".
& @zemit
@zemit <zone> = <message>
Emits a message to all rooms in <zone>. You must have control in that
zone in order to use this command. Because it is computationally
expensive, it costs 100 pennies.
& @wallpose
@wallpose <pose>
Sends a pose to all connected players. This command may be abbreviated to
"@wall :<pose>". It is only executable by wizards.
& @wallemit
@wallemit <message>
Sends an emit to all connected players. It is only executable by wizards.
& @decompile
@decompile <object>
This dumps the sequence of commands needed to recreate that object. It
is useful for keeping off-MUSH records of your valuable objects, and for
transferring code from one MUSH to another. Normal locks and enter locks
are decompiled, but attributes are not shown as locks.
& @move
@move <object> = <movement message>
This attribute stores the message shown to the object when the object moves.
& @omove
@omove <object> = <message>
This is a member of the family of o-messages. This is shown to the contents
of the location that the object moves to.
& @amove
@amove <object> = <action>
This is the action to be taken whenever an object moves.