Help Entries starting with 'M'

  The @mailfilter attribute specifies automatic filing of incoming
  @mail messages into folders. When an @mail message is received,
  the contents of @mailfilter are evaluated, with the following 
  arguments passed:
     %0     dbref of message sender
     %1     message subject
     %2     message body
     %3     message status flags (a string containing U, F, and/or R,
            for urgent, forwarded, and/or reply, respectively)

If @mailfilter evaluates to a folder name or number, the message will be filed into that folder. If @mailfilter evaluates to a null string, the message remains in the incoming folder.

> @mailfilter me=if(strmatch(%3,*U*),1)

• @malias [<alias>]

The @malias command is used to create, view, and manipulate @mail aliases, or lists. An alias is a shorthand way of specifying a list of players for @mail. Aliases begin with the '+' (plus) prefix, and represent a list of dbrefs; aliases may not include other aliases.

@malias with no arguments lists aliases available for your use, and is equivalent to @malias/list

@malias with a single argument (the name of an alias) lists the members of that alias, if you're allowed to see them. Other forms of the same command are @malias/members <alias> or @malias/who <alias>

See help @malias2 for more

• @malias[/create] <alias>=<playerlist>
• @malias/desc <alias>=<Description>
• @malias/rename <alias>=<newalias>
• @malias/destroy <alias>

The first form above creates a new alias for the given list of players. @malias/desc sets the alias's description, which is shown when aliases are listed. @malias/rename renames an alias. @malias/destroy destroys the alias completely.

See help @malias3 for more.

• @malias/set <alias>=<playerlist>
• @malias/add <alias>=<playerlist>
• @malias/remove <alias>=<playerlist>

@malias/set resets the list of players on the alias to <player list>. @malias/add adds players to the alias. Note that the same player may be on an alias multiple times. @malias/remove removes players from the alias. If a player is on the alias more than once, a single remove will remove only one instance of that player.

See help @malias4 for more.

• @malias/use <alias>=<permlist>
• @malias/see <alias>=<permlist>

@malias/use controls who may use an alias. Players who may use an alias will see it in their @malias list, and can @mail to the alias. @malias/see controls who may list the members of an alias.

An empty permission list allows any player. The permission list may also be a space-separated list of one or more of "owner", "members" (of the alias), and "admin".

By default, the owner and alias members may see and use the alias, but only the owner may list the members. Note that admin may always list aliases and their members, regardless of these settings, but are treated like anyone else when trying to @mail with an alias.

See help @malias5 for more.

• @malias/all
• @malias/stat
• @malias/chown <alias>=<player>
• @malias/nuke

@malias/all is an admin-only command that lists all aliases in the MUSH. @malias/stat is an admin-only command that displays statistics about the number of aliases and members of aliases in use. @malias/chown is a wizard-only command that changes the owner of an alias. @malias/nuke is a God-only command that destroys all aliases.

• @map[/delim] [<delim>]<list>=<functionorpattern>

This command takes a space-separated list of words, and performs pronoun/pattern substitution on each word, returning a list - "mapping" the function onto each item in the list. It returns the list in a MAPLIST attribute, automatically set on the object executing the @map. The set is always performed before any actions further actions are executed.

If the /delim switch is given, the first character of the list is used as the delimiter, instead of space.

Brackets are generally necessary in order to make the function substitutions evaluate correctly.

@map is an obsolete command provided for backwards compatibility; the ITER() or MAP() functions should probably be used instead.

See "help @map2" for examples of @map.

  Examples of @map:
    @map foobar baz blech=[strlen(##)]
      Returns "6 3 5" in MAPLIST.
    @map testing map-test=[strlen(before(##, est)]
      Returns "1 5" in MAPLIST
    @map Joe Bob Ann=I know ##.
      Returns "I know Joe. I know Bob. I know Ann." in MAPLIST

>  @va Object=$test * * *:@map %0 %1 %2=[strlen(##)];
@dolist [v(maplist)] = say ##
Object - Set.
>  test aaa bb c
Object says, "3"
Object says, "2"
Object says, "1"

• @motd[/<switch>][<message>].

The default for this command (and with the /connect) switch, is a wizard only command that will set a temporary message that will be shown to players when they connect. This MOTD is cleared every time the MUSH restarts.

Note that @motd by itself clears the message. Use @motd/list or @listmotd to see the current messages.

  Other switches:
  /wizard : sets the message for wizards (like @wizmotd)
  /down   : sets the logins-off message (like @rejectmotd)
  /full   : sets the max-players-logged-in message
  /list   : list the MOTDs (like @listmotd, can be used by anyone)

• @move <object>=<movementmessage>

  This sets the message that is shown to <object> whenever it moves.
  Example:
       @move me=You moved! You are now in the room: [name(loc(me))].

• @mail[/<switches>] [<msg-list>[=<target>]]
• @mail[/<switches>] <player-list>=[<subject>/]<message>

@mail invokes the built-in MUSH mailer, which allows players to send and receive mail. Pronoun/function substitution is performed on any messages you may try to send.

  A <msg-list> is one of the following:
        A single msg # (ex: 3)
        A message range (ex: 2-5, -7, 3-)
        A folder number and message number/range (ex: 0:3, 1:2-5, 2:-7)
        A sender (ex: *paul)
        An age of mail in days (ex: ~3 (exactly 3), <2, >1)
           "days" here means 24-hour periods from the current time.
        One of the following: "read", "unread", "cleared", "tagged",
        "urgent", "all" (all messages in all folders), "folder" (all
        messages in current folder)
  A <player-list> is a space-separated list of recipients, which may be:
        Player names
        Player dbref #'s
        Message #'s, in which case you send to the sender of that message.
        An alias name (see help @malias)

  See also the following topics:    mail-sending   mail-reading   
      mail-folders   mail-forward   mail-other     mail-admin     
      @malias

Mail functions work with @mail.

  folderstats() mail()        maildstats()  mailfrom()    mailfstats()
  mailsend()    mailstats()   mailstatus()  mailsubject() mailtime()
  malias()

• mail()
• mail(<player name>)
• mail([<folder #>:]<mail message #>)
• mail(<player>, [<folder #>:]<mail message #>)

Without arguments, mail() returns the number of messages in all the player's mail folders. With a player name argument, mail() returns the number of read, unread, and cleared messages <player> has in all folders. Only Wizards can use this on other players.

When given numeric arguments, mail() returns the text of the corresponding message in the current folder. The message number may also be prefaced by the folder number and a colon, to indicate a message in a different folder.

> think mail(3:2)
(text of the second message in the player's third folder)

The @mail command can also take the following switches:

    @mail/stats [<player>]    --  Basic mail statistics.
    @mail/dstats [<player>]   --  Also provides read/unread count.
    @mail/fstats [<player>]   --  Does all that, plus gives space usage.

    @mail/debug <action>[=<player>]
    @mail/nuke

Only wizards may stats players other than themselves. The mail statistics commands are computationally expensive and cost the same as @find.

The /debug switch does sanity checking on the mail database, and may only be used by a wizard. "@mail/debug sanity" just does the check; the command "@mail/debug clear=<player name or dbref number>" wipes mail for an object. "@mail/debug fix" attempts to repair problems noted in the sanity check.

The /nuke switch destroys the post office, erasing all @mail everywhere. It may only be used by God.

The MUSH mail system allows each player 16 folders, numbered from 0 to 15. Mail can only be in 1 folder at a time. Folder 0 is the "inbox" where new mail is received. Most @mail commands operate on only the current folder.

  @mail/folder
        This commands lists all folders which contain mail, telling
        how many messages are in each, and what the current folder is.

  @mail/folder <folder#|foldername>
        This command sets your current folder to <folder#>.

  @mail/folder <folder#> = <foldername>
        This command gives <folder#> a name. 

  @mail/unfolder <folder#|foldername>
        This command removes a folder's name

  @mail/file <msg-list>=<folder#>
        This command moves all messages in msg-list from the current
        folder to a new folder, <folder#>.

• @mailforwardlist me=<space-separatedlistofdbrefsorobjids>
• @lock/mailforward me=<lock>

By setting a @mailforwardlist attribute, a player can direct that @mail they receive should be delivered to the specified list of dbrefs of other players. The list may include the player's own dbref, in which case the player will receive a copy of the message, or omit it, in which case the message will be delivered to those listed but the player will not receive a copy.

To deliver messages to other players this way, you must control them (i.e. you're delivering to yourself or you're a wizard) or pass their @lock/mailforward. An empty @lock/mailforward disallows forwarding to you, and is the default.

  @mail/clear [<msg-list> | all]
  @mail/unclear [<msg-list> | all]
        These commands mark mail in the current folder as cleared or uncleared.
        Mail marked for clearing is deleted when you disconnect, or
        if you use @mail/purge. If no msg-list is specified, all
        mail in your current folder is cleared. If "all" is given instead
        of a msg-list, all mail in *all* folders is cleared/uncleared.

  @mail/purge
        Actually deletes all messages marked for clearing with @mail/clear.
        This is done automatically when you log out.

  @mail/tag [<msg-list> | all>]
  @mail/untag [<msg-list> | all>]
        These commands tag or untag mail in the current folder.
        Tagged mail can be later acted on en masse by using "tagged" as
        the msg-list for other commands (which does *not* untag them
        afterward). If no msg-list is specified, all messages in the
        current folder are tagged/untagged. If "all" is given as the
        msg-list, all mail in *all* folders is tagged/untagged.
        (Ex: To clear all mail from Paul and Chani, @mail/tag *paul,
        @mail/tag *chani, @mail/clear tagged, @mail/untag all).

  @mail <msg #>
  @mail/read <msg-list>
        This displays messages which match the msg# or msg-list from
        your current folder.

  @mail
  @mail <msg-list, but not a single msg #> 
  @mail/list <msg-list>
        This gives a brief list of all mail in the current folder,
        with sender name, time sent, and message status.
        The status field is a set of characters (ex: NC-UF+) which mean:
                N = New (unread) message
                C = Cleared message
                U = Urgent message
                F = Forwarded message
                + = Tagged message
        The opposites of these (read messages, etc.) are indicated with a
        '-' in the status field in that position.

  @mail[/switch] <player-list> = [<subject>]/<msg>
        This sends the message <msg> to all players in <player-list>.
        If no subject is given, the message subject is the beginning
        of the message itself.
        All function substitutions are valid in <msg> including mail(#) which
        will allow you to forward mail you have received to other users.
        The following switches are available:
                /send   - same as no switch
                /urgent - mail is marked as "Urgent"
                /silent - no notification to sender that mail was sent
                /nosig  - no mail signature
        If you have an @mailsignature attribute set on yourself, its
        contents will be evaluated and appended to the message unless
        the /nosig switch is given.

  @mail/fwd <msg-list> = <player-list>
        This sends a copy of all the messages in <msg-list> to
        all the players in <player-list>. The copy will appear to have
        been sent by you (not the original sender), and its status will
        be "Forwarded".

• mailfrom([<player>,] [<folder #>:]<mail message #>)
• mailtime([<player>,] [<folder #>:]<mail message #>)
• mailstatus([<player>,] [<folder #>:]<mail message #>)
• mailsubject([<player>,] [<folder #>:]<mail message #>)

mailfrom() returns the dbref number of the sender of a mail message. mailtime() is similar, but returns the time the mail was sent. mailsubject() is similar, but returns the subject of the message. mailstatus() returns the mail's status characters (as per @mail/list)

• mailsend(<player>,[<subject>/]<message>)

This function sends a message to a player, just like @mail/send. It returns nothing if successful, or an error message.

• mailstats([<player>])
• maildstats([<player>])
• mailfstats([<player>])

mail*stats() functions return data like @mail/*stats does. You either must use this on yourself, or you must be a wizard. The information will be joined together as a space separated list of numbers.

> think mailstats(One)
<# sent> <# received>
> think mailfstats(One)
<# sent> <# sent unread> <# sent cleared> <# sent bytes> <# received>
<# received unread> <# received cleared> <# received bytes>

• malias([<delimiter>])
• malias(<malias name>)
• malias(<malias name>[,<delimiter>])

With no arguments, malias() returns the list of all malias names which are visible to the player. With two arguments, returns the list of dbrefs that are members of the given malias, delimited by <delimiter>.

With one argument, the behavior is ambiguous. If the argument matches a malias, returns the list of dbrefs that are memebrs of the malias, space-delimited. If not, it's treated as a no-argument case with a delimiter.

• map([<object>/]<attribute>, <list>[,<delim>[, <osep>]])

Maps a function onto a list.

This function works much like ITER(). Each element of <list> has the user-defined function of the first argument performed on it; the element is passed to the function as %0, and its position in <list> as %1. <delim> is used as the element delimiter; if it is not specified, a space is used. The resulting output is delimited by <osep>, if given, or else by the delimiter

Examples:

    > &times_two me=[mul(%0,2)]

> say [map(times_two, 5 4 3 2 1)]
You say, "10 8 6 4 2"

> say [map(times_two,1;2;3;4;5,;)]
You say, "2;4;6;8;10"

• mapsql([<object>/]<attribute>, <query>[, <osep>[, <dofieldnames>]])

Performs an SQL query if the MUSH is configured to connect to an SQL database server. This function requires a WIZARD flag or the Sql_Ok power.

<query string> is evaluated, so it's useful to either read it from another attribute with u() or use lit() to protect commas. If you will be interpolating user-provided values into the query, be careful to escape them with sqlescape().

Each row of the result is passed to <attribute>, with columns as %1-%9. %0 is set to the row number, which will start with 1.

If <dofieldnames> evaluates to a true boolean, then the first call will be with row number 0 and %1-%9 will be set to the field names.

See 'help mapsql2' for examples.

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, meaning that they can be used anywhere on the MUSH. Normally, only wizards will have access to the Master Room; if you have a global command that you would like to see enabled for the MUSH, speak to a wizard.

• match(<list>, <pattern>[,<delimiter>])

This function tests if the pattern matches an element of the list. 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. If no match is found, 0 is returned. If a match is found, it returns the number of the element of the list that matched.

This attempts to match to a list element, not to an entire string. To match an entire string (for example, to match "red blue green" to "*bl*"), use the strmatch() function.

• matchall(<list>, <pattern>[,<delim>[, <osep>]])

This function works identically to the match() function, save that it returns all matches, not just the first: It returns the index numbers of all elements in <list> which match <pattern>. If none match, an empty string is returned. The resulting output is delimited by <osep>, if given, or else by the delimiter.

Examples:

> say matchall(This is a test of a test,test)
You say "4 7"
> say matchall(This is testing a test,tes*)
You say "3 5"

  Matching is the process the MUSH uses to determine which object you
  mean when you try to do something with an object. Different commands
  do matching in different ways, but most will allow you to specify
  an object as:
    * its dbref (#7)
    * its full name (Box of chocolates)
    * part of any word in its name, if nothing else shares that part (Box)
    * me (yourself)
    * here (the room you're in)
  Usually, you can also qualify an object with an adjective to help
  the MUSH determine which object you mean.  Adjectives include:
    * my <obj> - an object you're carrying
    * this <obj> - an object in your location (also: this here <obj>)
    * toward <exit> - an exit in your location
    * 1st, 2nd, etc. <obj> - one of a set of objects with the same names.
      Objects are ordered in the order in which they're listed in your
      inventory, room contents, and exit list (in that order). If there
      aren't enough objects, this will fail.
   You may combine some adjectives (my 1st box, this here 2nd box).

  Math functions take one or more floating point numbers and return 
  a numeric value.
  abs()         acos()        add()         asin()        atan()
  atan2()       bound()       ceil()        cos()         ctu()
  dist2d()      dist3d()      e()           exp()         fdiv()
  floor()       fmod()        fraction()    ln()          lmath()
  log()         max()         mean()        median()      min()
  mul()         pi()          power()       root()        round()
  sign()        sin()         sqrt()        stddev()      sub()
  tan()         trunc()       val()

  These functions operate only on integers (if passed floating point
  numbers, they will return an error or misbehave):
  dec()         div()         floordiv()    inc()         mod()
  remainder()

  These functions operate on n-dimensional vectors. A vector
  is a delimiter-separated list of numbers (space-separated, by default):
  vadd()        vcross()      vdim()        vdot()        vmag()
  vmax()        vmin()        vmul()        vsub()        vunit()

• max(<number>[, ... , <numberN>])

This function returns the largest number in its list of arguments. It can take any number of arguments.

  The word 'me' refers to yourself. Some things to do when 
  starting out: 
  1) give  yourself a description:      @desc me=<description>
  2) check your desc.:                  look me
  3) lock yourself:                     @lock me==me
  4) set your gender:                   @sex me=<male|female|neuter|plural>

• mean(<number>[, ... , <numberN>])

Returns the mean (arithmetic average) of its arguments.

• median(<number>[, ... , <numberN>)

Returns the median (the middlemost numerically) of its arguments.

• member(<list>, <word>[,<delimiter>])

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'

member() is case-sensitive and requires an exact match. For wild card patterns, use match().

• merge(<string1>, <string2>, <characters>)

This function merges <string1> and <string2>, depending on <characters>. If a character in <string1> is the same as one in <characters>, it is replaced by the character in the corresponding position in <string2>. The two strings must be of the same length.

> say [merge(AB--EF,abcdef,-)]
You say, "ABcdEF"

Spaces need to be treated specially. An empty argument is considered to equal a space, for <characters>.

> say [merge(AB[space(2)]EF,abcdef,)]
You say, "ABcdEF"

• 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. If <length> is negative, it returns characters to the left of the <first> character. The <first> character is always part of the <length> characters.

> say mid(foobar, 2, 2)
You say, "ob"
> say mid(foobar, 2, -2)
You say, "oo"

• min(<number>[, ... , <numberN>])

This function returns the smallest number in its list of arguments. It can take any number of arguments.

Flag: MISTRUST (things, rooms, exits)

Mistrust prevents an object from controlling anything but itself. This will also usually prevent it from examining anything else non-VISUAL owned by the same player. It also prevents the object from benefitting from its owner's no_pay, no_kill, and no_quota powers, if any.

This flag can be used when you wish a single player to retain ownership of objects that other players will use to run arbitrary commands, and don't want those objects to be able to affect your objects.

(Note, however, that a Wizard object will ignore this flag, a see_all object will still be able to examine anything, a no_pay object will still have unlimited money, etc. This flag works best when no other privileges are granted to the object.)

• mix([<object>/]<attribute>, <list 1>, <list 2>[, ... , <list n>,<delim>])

This function is similar to MAP(), except that it takes the elements of two or more lists, one by one, and passes them to the user-defined function as %0, %1, up to %9, respectively, for elements of <list 1> to <list 10>. If the lists are of different sizes, the shorter ones are padded with empty elements. <delim> is used to separate elements; if it is not specified, it defaults to a space. If using more than 2 lists, the last argument must be a delimiter.

See 'MIX2' for examples

Examples of mix():

> &add_nums me=[add(%0, %1)]
> say [mix(add_nums,1 2 3 4 5, 2 4 6 8 10)]
You say, "3 6 9 12 15"
> &lengths me=[strlen(%0)] and [strlen(%1)].
> say [mix(lengths, some random, words)]
You say, "4 and 5. 6 and 0."
> &add_nums me=[add(%0, %1, %2)]
> say [mix(add_nums, 1:1:1, 2:2:2, 3:3:3, :)]
You say, "6:6:6"

• mod(<number>, <number>)
• modulo(<number>, <number>)
• modulus(<number>, <number>)
• remainder(<number>, <number>)

Remainder returns the remainder of the integer division of the first number by the second. Modulo returns the modulo of the two numbers. For positive numbers, these are the same, but they may be different for negative numbers:

     modulo(13,4)       ==>  1      and     remainder(13,4)    ==>  1
     modulo(-13,4)      ==>  3      but     remainder(-13,4)   ==>  -1
     modulo(13,-4)      ==>  -3     but     remainder(13,-4)   ==>  1
     modulo(-13,-4)     ==>  -1     and     remainder(-13,-4)  ==>  -1 

Remainder result always has the same sign as the first argument. Modulo result always has the same sign as the second argument.

Mod and modulus are just aliases for modulo.

The MUSH has a built-in money system, which gives a starting amount of money to new players and hands out a daily allowance thereafter. MUSH money (the default name is "pennies", but this may be different depending on the particular MUSH) is spent on some MUSH commands that are computationally expensive or alter the database. In addition, every time you "queue" a command, it costs you a certain amount of money -- this prevents looping from getting out of control, since when all your money is spent, you can't queue any more commands.

The money system can also be used on player-created objects by giving them @cost/@payment/@opayment/@apayment attributes. When someone then pays the object by giving it the right number of pennies, the attributes are triggered.

• money(<object>)
• money(<integer>)

The first form returns the amount of money <object> has. The second form returns the name for a given amount of money, appropriately inflected as singular or plural.

> say [money(Javelin)]
You say, "150"

> say [money(1)]
You say, "Penny"

> say [money(2)]
You say, "Pennies"

> &counter me=$count *: @emit %0 [money(%0)]
> count 2
2 Pennies

Flag: MONITOR (players)

When set on a player, this flag notifies that player when anyone connects to or disconnects from the MUSH. It is valid only for players, and must be set by a wizard (although royalty may set themselves MONITOR).

Flag: MONITOR (things, rooms)

When set on a thing or room, this flag activates the ^ listen patterns on the object. Objects which have ^ listen patterns but are not set MONITOR do not check those patterns.

When using the LISTEN Attribute Tree, you must set the Root Attribute !NO_COMMAND. By default this Attribute/Attribute Root has been set NO_COMMAND by the system. Attributes which are set HALT or NO_COMMAND will not be evaluated for purposes of the ^ listen patterns

The MORTAL flag is no longer available in PennMUSH. Please see help changes for more information.

• mtime(<object>[, <utc>])
• msecs(<object>)

If creation times are enabled, this function will return the date and time that one of the object's attributes was last added, deleted, or modified. Only things, rooms, and exits have modification times. If the optional <utc> argument is true, the time is returned for the UTC time zone, if false or present, for the local time zone.

msecs() returns the time as the number of seconds since the epoch.

You must be able to examine an object to see it's modification time.

• 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 any inter-mush bots like mudnet that it's
  connected to.
  Example:
    > say mudname()
    You say "TestMUSH"

• mul(<number>, <number>[, ... , <numberN>])

Returns the product of some numbers.

• munge([<object>/]<attribute>, <list 1>, <list 2>[,<delimiter>[, <osep>]])

This function takes two lists of equal length. It passes the entirety of <list 1> to the user-defined function as %0, and the delimiter as %1. Then, this resulting list is matched with elements in <list 2>, and the rearranged <list 2> is returned. This is useful for doing things like sorting a list, and then returning the corresponding elements in the other list. If a resulting element from the user-defined function doesn't match an element in the original <list 1>, a corresponding element from <list 2> does not appear in the final result.

See 'MUNGE2' for examples.

and another attribute DBREFS contains the dbrefs of the main JUMP_OK
location of these areas, "#20 #9000 #5000".  We want to return a list of
dbrefs, corresponding to the names of the places sorted alphabetically. The
places sorted this way would be "Benden Fort Ista", so we want the final
list to be "#9000 #20 #5000". The functions, using munge(), are simple:

> &sort me=[sort(%0)]
> say [munge(sort,v(places),v(dbrefs))]
You say, "#9000 #20 #5000"

See 'MUNGE3' for another example.

Another common task that munge() is well suited for is sorting a list of dbrefs of players by order of connection. This example reuses the &sort attribute from the previous one, but unlike the other example, it builds the list to sort on out of the list to return.

> &faction_members me=#3 #12 #234
> say [munge(sort,iter(v(faction_members),conn(##)),v(faction_members))]
You say, "#12 #234 #3"

MUSHcode is the programming language available within the MUSH itself with which you can create user-defined commands and macros. It is sometimes called "softcode" to distinguish it from "hardcode", which is the language that the source code for the MUSH server is written in. (Incidentally, hardcode is written in the C programming language.)

At its most basic, writing MUSHcode is just stringing together a series of commands that you would otherwise just type in one at a time. You can store MUSHcode in attributes on any type of object you own or control (including yourself!). The series of commands can be triggered by using a user-defined command or by using @trigger.

(continued in help mushcode2)

If you would like to learn more about mushcoding and how to create macros for yourself, the following help files may be useful. However, the best way to learn is by obtaining a copy of Amberyl's MUSH manual and following the examples described there. The manual is available by anonymous FTP from: ftp.pennmush.org in the directory /pub/PennMUSH/Manuals

  Related Help Topics (in no particular order)
  -------------------
  ATTRIBUTES    SUBSTITUTION    NON-STANDARD ATTRIBUTES 
  ENACTOR       EXECUTOR        USER-DEFINED COMMANDS
  DBREFS        EVALUATION      TYPES OF OBJECTS
  WILDCARDS     STRINGS         LISTS           
  ACTION LISTS

• mwho()
• mwhoid()

mwho() returns a list of the dbref numbers for all current-connected, non-hidden players. It's exactly the same as lwho() used by a mortal, and is suitable for use on privileged global objects who need an unprivileged who-list.

mwhoid() returns a list of objids instead.

Flag: MYOPIC (players)

Myopic is a flag which suppresses the printing of an object's dbref number and abbreviated list of flags when it is looked at. It makes the world appear like you don't control any of it, even if you're a wizard or royalty. It's useful if you don't like to see object numbers. This flag is only valid for players; objects belonging to MYOPIC players are automatically considered to be MYOPIC.