Sets the leave alias(es) of an object that is ENTER_OK. Setting a leave alias allows people to type the leave alias instead of the "leave" command in order to get out of the object. Meaningless for exits and rooms.
You can set multiple leave aliases on an object by separating them with
semi-colons.
Example:
@lalias chair=stand up;stand;get up;rise
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". This command is the same as "@emit/room".
The /silent switch suppresses the normal confirmation message.
The /noeval switch prevents <message> from being evaluated.
The /spoof switch causes nospoof notifications to show the enactor's
dbref instead of the executor's dbref, and requires control over
the enactor or the Can_nspemit power.
This is the message shown to the player who fails to leave the object, either because the object is set NO_LEAVE or because the person leaving fails the leave-lock.
Links <object> to either a room or a thing. If a thing or player is linked, that sets the object's HOME. If a room is linked, that sets the object's drop-to room, which is where objects that are dropped in the room will be sent to.
Most often, @link is used to link or relink an exit to a destination room. In order to link an exit to a room, you must either own or control the room, OR the room must be set LINK_OK. If the exit is currently unlinked, and you pass its @lock/link, you may link it even if you do not own it. In this case, the exit will be @chowned to you (and set HALT). Linking an exit may have a cost (usually 1 penny.) The Wizard-only /preserve switch can be used to link without @chowning and HALTing the exit.
If the destination of an exit is "variable", its destination is determined at the time of travel by the attribute DESTINATION on the exit, which is evaluated like a U()-function. You must have permission to link to whatever the DESTINATION evaluates to in order for the exit to work. If there's no DESTINATION attribute, the EXITTO attribute is also tried.
If the destination is "home", those who travel through the exit will be sent to their homes.
LINK_OK objects can also be used as semaphores, and any object can be @parented to them.
The @list command lists useful MUSH information.
Switches include: /motd : Alias for @listmotd, shows current messages of the day. /functions : Alias for @config/functions, shows all functions /commands : Alias for @config/commands, shows all commands /attribs : Alias for @config/attribs, shows all standard attribs /locks : Shows all global (non-user) locks. /flags : Alias for @flag/list, shows all flags /powers : Alias for @powers/list, shows all powers /lowercase : Show whatever you're showing in lowercase, rather than upper.
Some commands that require the use of '@list <what>' and don't work as '@list/<what>':
allocations : Information about memory allocations.
Sets the object's listen pattern to <string>, which can have wildcards. Whenever something the object hears matches the pattern, the object's ahear/amhear/aahear attribute will be triggered. In addition, anything inside the object will hear it as well.
For example:
@listen Chair = *
Since the wildcard (*) matches anything, anyone inside the object will
hear anything said outside it.
@listen Butler = * has arrived.
@ahear Butler = :walks over to the new arrival and takes %p coat.
> Cyclonus has arrived.
> Butler walks over to the new arrival and takes his coat.
In this case, the listen pattern is met whenever someone 'arrives' in
the room, and then the object does whatever is inside its @ahear
attribute.
(continued in help @listen2)
An object "hears" anything that another player standing in the same room would hear. For example, if you type in a command, the object does NOT hear it. If the command has a result that people in the room hear, the object will hear it.
For example:
@listen Recorder = @emit *
@ahear Recorder = :records {%0}
@emit Whee!
> Whee!
In this example, the Recorder's listen-pattern is NOT matched, because
it doesn't hear the '@emit Whee!', it only hears the 'Whee!' part, which
doesn't match.
@listen Recorder = Cyclonus says, "*" "Whee! > Cyclonus says, "Whee!" > Recorder records: Whee!
This command lists the current MOTD (message of the day) for the MUSH. If used by a wizard or admin, it will also include the wizard, full, and down MOTDs to the user. Same as @list/motd.
See also:
You can test for an object id, instead of a dbref, with:
@lock <object>=objid^<object id>
You can test to see if the enactor is a member of a space-separated list of dbrefs or objids on an atrribute on the object, with:
@lock <object>=dbreflist^<attributename>
For example,
&allow Commands = #1 #7 #23 #200:841701384
&deny commands = #200 #1020
@lock/use commands = !dbreflist^deny & dbreflist^allow
You can lock an object in several different ways. The simplest lock is to
lock it to one other object with the '=', signifying a DBRef # match.:
@lock My Toy = = me
This locks the object "My Toy" to you and you alone. It is recommended
that you @lock me == me in order to prevent anyone else from picking
you up. The two = signs are NOT a typo! The first is part of the @lock
syntax (as shown at the top of "help @lock") the second is a lock key
that means "exactly this object".
You can lock an object -against- another object as well, using the '!'
symbol before any other key:
@lock Shared Toy = !Vector Sigma
This locks the object "Shared Toy" to everyone -except- Vector Sigma.
Everyone except Vector will be able to pick up the object.
(continued in help @lock3)
You can lock an object to something that has to be carried:
@lock Door = +Secret Door Key
This locks the exit "Door" to someone carrying the object "Secret Door
Key". Anyone carrying that object will be able to go through the exit.
You can lock an object to -either- an object or to someone carrying the
object with:
@lock Disneyworld Entrance = Child
This locks the exit "Disneyworld Entrance" to either the object
"Child" -or- to someone carrying the object "Child". (OK, so it's
a weird example.)
You can lock an object to a specific player by using a *:
@lock Note == *Jazz
Only the player "Jazz" will be able to pick up the Note object.
(continued in help @lock4)
An "owner" lock allows you to lock something to anything owned by the
same player:
@lock Box = $My Toy
This locks "Box" to anything owned by the owner of "My Toy" (since
players own themselves, that includes the owner as well).
An "indirect" lock allows you to lock something to the same thing as
another object (very useful in setting channel locks; see help @clock):
@lock Second Puppet = @First Puppet
This locks the object "Second Puppet" to whatever the object
"First Puppet" is locked to. Normally, the lock type that is checked
is the same as the lock on the first. You can specify a different
lock type with @object/LOCKNAME. For example:
@lock Second Puppet = @First Puppet/Use
Second Puppet's basic lock now checks First Puppet's use lock.
There are also some more complex locks called attribute and evaluation locks. In addition, you can make complex locks (combining several types or reversing them).
(continued in help @lock5)
ATTRIBUTE LOCKS You can lock an object to an attribute on the person trying to pass the lock (as long as the object can "see" that attribute):
@lock <object>=<attribute>:<value>
<value> can contain wildcards (*), greater than (>) or less than (<) symbols.
Example:
@lock Men's Room = sex:m* This would lock the exit "Men's Room" to anyone with a SEX attribute starting with the letter "m". @lock A-F = icname:<g This would lock the exit "A-F" to anyone with a ICNAME attribute starting with a letter "less than" the letter "g". This assumes that ICNAME is visual or the object with the lock can see it.
(continued in help @lock6)
COMPLEX LOCKS
You can combine or reverse locks very easily using the following
BOOLEAN symbols and parentheses () to group them:
& - "and"
| - "or"
Example:
@lock My Toy = =me | !*Chromia | +Toy Box Key This locks "My Toy" to me, -against- the player Chromia, or to anyone carrying the object "Toy Box Key". @lock My Toy = *Marissa & +Toy Box Key This locks "My Toy" to the player Marissa, who needs to be carrying the object "Toy Box Key". @lock My Toy= *Chromia | ( *Marissa & +Toy Box Key ) This locks it to Chromia, OR to Marissa if she is carrying the Key.
(continued in help @lock7)
EVALUATION LOCKS An evaluation lock is set using this format:
@lock <object>=<attribute>/<value>
The difference between this and an attribute lock is that the <attribute> is taken from <object> rather than from the person trying to pass the lock. When someone tries, <attribute> is evaluated, and the result is compared to <value>. If it matches, then the person passes the lock.
The person trying to pass the lock is %# and <object> is %! when the evaluation takes place. The evaluation is done with the powers of <object>. If you try to do something (like [get(%#/<attribute>)]) and <object> doesn't have permission to do that, the person will automatically fail to pass the lock.
(continued in help @lock8)
Example:
@lock Stage = ispuppet/1 &ispuppet Stage = hasflag(%#, PUPPET) This locks the object "Stage" to puppets only.
Whenever someone tries to pick up the object, the attribute
"ispuppet" will be checked, substituting in the person's DBREF number
for %#.
[hasflag(<dbref>, PUPPET)] will come out to 1 if the object with
<dbref> has the "PUPPET" flag. Otherwise, it will come out to be 0.
Since the value in the @lock is 1, only objects with the PUPPET flag
will be able to pass this lock.
(continued in help @lock9)
You can also test for set flags, powers, or object types in a lock directly, without using an evaluation lock, with these formats:
@lock <object>=flag^<flag>
@lock <object>=type^<type>
@lock <object>=power^<power>
These locks act like the object the lock is on does a hasflag(%#, <flag>), hastype(%#, <type>), or haspower(%#, <power>) succeeding if the flag is set.
You can test for channel membership with:
@lock <object>=channel^<channel>
For example,
@lock/use Admin Commands=flag^wizard|flag^royalty
(continued in help @lock10)
This wizard-only command puts <message> in a log file, tagged with the time and object executing the command. The available switches are /check, /cmd, /conn, /err, /trace, and /wiz, specifying which file to log to. /cmd is default.
See also:
This God-only command erases one of the MUSH logs. Available switches are /check, /cmd, /conn, /trace, and /wiz. God must give the log wipe password from the MUSH's configuration file to use this command.
See also:
This commands sets or clears flags on locks. Valid flags include:
visual (v) This lock can be seen even if the object it's on
isn't visual.
no_inherit (i) This lock isn't inherited off of parents. All locks
are set no_inherit by default.
no_clone (c) This lock isn't copied by @clone.
wizard (w) This lock can only be set by wizards.
locked (+) This lock can only be set by the owner of the lock.
LAST and LASTLOGOUT
These attributes show the last times you connected and disconnected from the MUSH.
LASTSITE and LASTIP
The LASTSITE attribute gives the name of the site you last connected from. The LASTIP attribute gives the IP address you last connected from. Mortals cannot set them.
Returns a delim-separated list of the attribute names on the object that you are permitted to examine. To see the complete list, you must either be a Wizard or Royalty, own the object, have the See_All power, or have the object set VISUAL in order to use this function on the object. The delimiter defaults to space if not given.
If a wildcarded attribute pattern is provided, only attribute names matching that pattern will be returned. lattr() uses the same wildcards as examine (?, *, **).
lattrp() also includes attributes inherited from parents.
Returns a list of the dbrefs of contents in a container.
You can get the complete contents of any container you may examine, regardless of whether or not objects are dark. You can get the partial contents (obeying DARK/LIGHT/etc.) of your current location or the enactor (%#). You CANNOT get the contents of anything else, regardless of whether or not you have objects in it.
See also:
Returns <string> with all letters converted to lowercase. Example: lcstr(Foo BAR bAz) returns "foo bar baz"
This deletes the item at <position> in the list. If a separator character is not given, a space is assumed. Null items are counted, as in 'items()'.
Example:
> say [ldelete(This is a long test string,4)] You say, "This is a test string" > say [ldelete(lemon|orange|apple,2,|)] You say, "lemon|apple"
The command leave allows you to exit an object you have enter'ed into. When you leave an object, its @leave/@oleave/@oxleave messages are triggered, and its @aleave actions are triggered.
The NO_LEAVE flag may be enabled on some MUSHes. Objects set with this flag cannot be left. @lock/leave may also be enabled on some MUSHes, which allows you to set who can leave the object. If you fail to leave, the object's @lfail/@olfail/@alfail messages/actions will be triggered.
letq() saves the current values of the given q-registers, sets them to new values, evaluates <expr> and then restores the saved registers. It does not restore registers that are not listed. None of the values can see the updated contents of the registers -- they are only visible to <expr>.
It returns the result of <expr>.
Example:
Example:
> think [setr(A, 1)]:[letq(A, 2, %qA)]:%qA 1:2:1
See also:
Returns a list of the dbrefs of exits in a room.
You can get the complete exit list of any room you may examine, regardless of whether or not exits are dark. You can get the partial exit list (obeying DARK/LIGHT/etc.) of your current location or the enactor (%#). You CANNOT get the exit list of anything else, regardless of whether or not you have objects in it.
Lflags returns a space-separated list consisting of the names of flags attached to the object or the attribute on the object.
Given no arguments, this function returns a space-separated list of all flag names known to the server.
See also:
Flag: LIGHT (all types)
Objects, players, and exits which have the LIGHT flag set on them (and are not also set DARK) appear in the contents of DARK rooms.
See also:
This function links object <name> to <destination>. While normally used on exits, it has all of the other capabilities of @link as well. It returns nothing. If the optional third argument is true, acts like @link/preserve.
This is a side-effect function and may not be enabled on some MUSHes.
Flag: LINK_OK (rooms, things)
If a room or object is LINK_OK, anyone can link exits to it (but still not from it). Also, LINK_OK overrides the TRUST protection against @trigger (although not @force or @set). This also allows others to @parent their objects to the thing set LINK_OK.
See @link, TRUST, @parent, PARENTS
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.
List functions take at least one list of elements and return transformed lists or one or more members of those lists. Most of these functions can take an arbitrary <delimiter> argument to specify what delimits list elements; if none is provided, a space is used by default.
element() elements() extract() filter() filterbool() first() fold() grab() graball() index() insert() itemize() items() iter() last() ldelete() map() match() matchall() member() mix() munge() namegrab() namegraball() remove() replace() rest() revwords() setdiff() setinter() setunion() shuffle() sort() sortby() sortkey() splice() step() table() unique() wordpos() words()
See also:
This function takes the same arguments as the @list command, and returns the same things.
Flag: LISTEN_PARENT (things, rooms)
When set on a thing or room which also has the MONITOR flag set, this flag causes ^ listen patterns to be checked on the object's parents as well as on the object.
There are two basic ways to trigger action on the MUSH. The basic way is to type in commands such as 'look' or '@emit'. These commands are not seen or heard by other players, although the results of the commands may be.
The other way is to "listen" for something said/emitted in your hearing. 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.
Example:
> @listen Welcome Mat=* has arrived. > @ahear Welcome Mat="Welcome, %N! Breaker has arrived. Welcome Mat says, "Welcome, Breaker!"
(continued in help listening2)
By default, ^-patterns work like @ahear. To have them work like @amhear, set the AMHEAR attribute flag on the attribute; to have them work like @aahear, set the AAHEAR attribute flag on the attribute (Note that the triggering object is whatever happens to be %#, so, for example, when you @set an object MONITOR, you are %# with regard to the "Object is now listening" message, and this message can be picked up with an ^pattern.)
Additionally, unlike $-commands, @listen and ^-patterns are NOT inherited via @parent, unless the LISTEN_PARENT flag is set on the listener.
Listen patterns are checked after the object's normal @listen attribute.
See also: @listen, @ahear, @amhear, @aahear, MONITOR, LISTEN_PARENT, USER-DEFINED COMMANDS
The word "list" is used in the help files to refer to a string that is a series of smaller strings separated by one or more spaces. A list can also have its elements separated by some other kind of character -- the separating character is called the "delimiter". For example, the following are all lists:
#6 #10 #14 #12
Rumble|Krystal|Bobatron|Rodimus Prime ('|' is the delimiter here)
foo bar whee blarg
-eek- .boing. yawp #5 7
Lots of MUSHCode depends on lists and manipulating them. Normally, a list is made up of similar items (so the fourth list in the example is NOT a typical one).
See also:
This function returns the string literally - without even squishing spaces, and without evaluating *anything*. This can be useful for writing ASCII maps with spaces or whatever.
It can be a bit tricky to get a literal string with spaces into an attrib, however, since spaces are usually squished in setting an attribute. This example illustrates how to make it work:
Example:
> @va me=$test: think {[lit(near far)]}
Set.
> ex me/va
VA [#1]: $test: think {[lit(near far)]}
> test
near far
Leaving out the {}'s will not work in the above.
This function pads a string with trailing characters ("left-justifies") so it is <length> long. If <string> is longer than <length>, the <string> is returned; it is not truncated. If <fill> is not specified, a space is used.
Examples:
Example:
> say [ljust(foo,6)] You say, "foo "
Example:
> say %r0[ljust(foo,6,-)]7%r01234567 You say, " 0foo---7 01234567"
llockflags returns a space-separated list consisting of the names of flags attached to the specified lock on the object.
Given no arguments, this function returns a space-separated list of all flag names known to the server.
See also:
llocks(), aliased locks(), list locks set on <object>, including user-defined locks (prefixed with USER:)
Example:
> @lock me==me > @lock/use me==me > @lock/user:itsme me==me > th llocks(me) Basic USER:ITSME Use
See also:
This function performs generic math operations on <list>, returning the result. Each element of the list is treated as one argument to an operation, so that lmath(<op>, 1 2 3) is equivalent to <op>(1, 2, 3). Using @function, one can easily write ladd, lsub, etc as per TinyMUSH.
Supported <op>'s are: add and band bor bxor dist2d dist3d div fdiv max mean median min modulo mul nand nor or remainder stddev sub xor
Example:
>think lmath(add, 1|2|3, |) 6 >think lmath(max, 1 2 3) 3 >&FUN_FACTORIAL me=[lmath(mul,lnum(1,%0))] >think u(fun_factorial,5) 120
With one argument, 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. With two arguments, the numbers range from the first to the second argument. For example, lnum(1,4) => 1 2 3 4 With three arguments, the output is separated by the separator given in the third argument. lnum(1,4,|) => 1|2|3|4
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. The location of an exit is its destination (the source of an exit is its home). The location of a room is its drop-to (if one is not set, then the location is #-1).
Localize() saves the q-registers, evaluates its argument, and restores the registers afterwards. It has much the same relation to s() that ulocal() does to u(), except localize()'s argument is only evaluated once, instead of twice like s()'s. Useful in @functions or to wrap around fragments of code too small to go into another attribute.
Example:
> say [setr(0, Outside)]-[s(\[setr(0, Inside)\])]-%q0 You say, "Outside-Inside-Inside" > say [setr(0, Outside)]-[localize(setr(0, Inside))]-%q0 You say, "Outside-Inside-Outside"
This function attempts to find the number called <name> relative to <looker>. You must control <looker> or have the See_All power. This is a bit like the NUM() function, but with a wider, controllable "range".
You can control the preferred type of the match with:
E - Exits
L - Unlocked exits preferred over locked exits
N - No type (this is the default)
P - Players
R - Rooms
T - Things
F - Return #-1 if what's found is of a different type than the
preferred one.
X - Never return #-2. Use the last dbref found if the match is
ambiguous.
If you specify more than one type, any will be preferred. Unless
you specify an F option, if an object of a different type is found and
none of the preferred type are, the found object will be returned.
(Read "help locate2" for more.)
You can control where to look with:
a - Absolute match (look for #<object>)
c - Exits carried by <looker>
e - Exits in <looker>'s location
h - "here" (the location of <looker>)
i - Inventory of <looker>
l - Location (container) of <looker>
m - "me" (<looker> itself)
n - Neighbors (other objects in same location as <looker>)
p - Player names prefixed by '*'
y - Player names with or without a '*' prefix
z - English-style matching (my 2nd book) of <name>
* - All of the above (try a complete match)
Just string all the parameters together, without separating them by spaces, i.e. LOCATE(#100, Test, Tn) would check #100's neighbors for an object named "Test", preferring a thing over other types.
More standard lock types:
@lock/speech Who can speak/pose/emit in this room @lock/listen Who can trigger my @ahear/^-pattern actions @lock/command Who can trigger my $-pattern commands @lock/leave Who can leave this object (or room, via exits/@tel) @lock/drop Who can drop this object or in this room @lock/give Who can give this object @lock/follow Who can follow this object @lock/examine Who can examine this object if it's VISUAL @lock/chzone Who can @chzone to this object if it's a ZMO @lock/forward Who can @forwardlist a message to this object @lock/control Who can control this object (only if set) @lock/dropto Who can trigger this container's drop-to. @lock/destroy Who can destroy this object if it's DESTROY_OK @lock/interact Who can send sound (say/pose/emit/etc) to this object @lock/take Who can get things contained in this object
lock() returns the text string equivalent of the lock on an object that you control. You can also provide a locktype (e.g. "enter", "use", etc.) switch after the object, if you want to check something other than the regular lock. If a new value is specified, it will attempt to change the lock before reporting it.
This is a side-effect function and may not be enabled on some MUSHes.
See also: @lock, locktypes, elock(), lockflags(), llockflags(), lset(), llocks()
lockflags() returns a string consisting of the flags attached to the specified lock on the object. The string is a single word made up of all the appropriate flag letters.
Given no arguments, this function returns a string consisting of all the flag letters the server knows.
See also:
This command "locks" the object, specifying a key which determines who or what can do certain things with the object. There are many different types of locks, all of which are described in "help locktypes" and which are designated by the switch. The "basic" lock determines, for players and things, who can pick them up. For exits, it determines who can go through the exit. All other locks can be set the same way as the basic lock.
Whenever you "pass" the basic lock, you succeed in doing something with the object. This triggers the @success/@osuccess/@asuccess messages and actions. If you fail to pass the basic lock, you trigger the @failure/@ofailure/@afailure messages and actions. Other locktypes may also have such success/failure messages: see "help failure" for info.
You can specify <object> and <key> as either the name of an object in the immediate area, a DBREF number, "me", or "here".
(continued in help @lock2)
Your MUSH will almost certainly support these standard lock types:
@lock/basic Who can pick up the player/object, or go through
the exit.
@lock/enter Who can enter the player/object (aka @elock)
@lock/teleport Who can teleport to the room
@lock/use Who can use the object (aka @ulock)
@lock/page Who can page/@pemit the player
@lock/zone Who can control objects on this zone
@lock/parent Who can @parent something to this object/room
@lock/link Who can @link something to this object/room
or who can @link this unlinked exit.
@lock/mail Who can @mail the player
@lock/user:<name> User-defined. No built-in function of this lock,
but users can test it with elock()
See 'help locktypes2' for more
LOGOUT is similar to QUIT, but instead of disconnecting you from the game completely, it merely disconnects you from your current character and returns you to the opening welcome screen. This is useful if you want to disconnect and then reconnect to another character. Unlike most commands, it is case-sensitive and must be typed in all caps.
look [<object>] look <person>'s <object> look/outside
Displays the description of <object>, or the room you're in if you don't name a specific object. You can specify object as <name> or #<dbref> or 'me' or 'here'. On some MUSHes, 'read' may work the same as 'look'. The second form of this command allows you to look at objects held by other people, if the person is not OPAQUE.
Look can take one switch, "outside". look/outside allows you to look at objects outside your current location, as long as your immediate location is not a room, and is not OPAQUE.
(continued in help look2)
If you look at an object that is not set OPAQUE, you will see any non-DARK items in its inventory. You can look at DARK items in your location if you know what their name is by typing 'look <object>', but they will not show up in the list of contents.
When you type 'look' alone, you look at your current location. For a room, this normally shows you the room's description, the list of contents, and any obvious exits from the room. For an object, it only shows you the interior description (@idescribe).
If a room is set DARK, when you look you will not see any of the exits or contents of the room, unless they are set LIGHT.
'look' may be abbreviated 'l'.
See also:
Looping in an object can have its good parts and its bad parts. The good part is when you activate part of a program multiple times to exhaustively perform an operation. This can be done like this:
&PART1 object=<action list> ; @trigger me/PART2
&PART2 object= @select <test for being done>=<false>,@trigger me/PART1
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 pennies while you are away from the mush!
Flag: LOUD (all types)
A LOUD object overrides speech, channel speech, and interaction locks. This flag can only be set by royalty or wizards.
This function returns a list consisting of the object's db# (as per num()), the db# of its parent, grandparent, greatgrandparent, etc. The list will not, however, show parents of objects which the player is not privileged to examine.
This function returns the dbrefs of all players, connected or not, in <object>. DARK wizards aren't listed to mortals or those without the see_all power. You must be in <object> or control it to use this function.
See also:
These function returns the list of descriptors ("ports") that are used by connected players. lports() returns all ports, in the same order as lwho() returns dbrefs, and ports() returns those a specific player is connected to, from most recent to least recent. Only players who are See_All or privileged may use these functions; in other cases, lports() returns #-1, and ports() an empty list. As an exception, players can use ports() on themselves.
These port numbers also appear in the wizard WHO, and can be used with @boot/port, page/port, and the functions that return information about a connection to make them use a specific connection rather than the least-idle one when a player has multiple connections open. Players can get information about their own connections. See_all is needed to use them to get information about other people's ports.
See also:
This function returns a list of the positions where <character> occupies in <string>, with the first character of the string being 0. Note that this differs from the pos() function, but is consistent with other string functions like mid() and delete().
If <character> is a null argument, space is used. If <character> is not found anywhere in <string>, an empty list is returned.
Example:
> say lpos(a-bc-def-g, -) You say, "1 4 8"
See also:
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 at least 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>.
The possible <class>es and <restriction>s are the same as those accepted by @search. lsearch() can accept multiple class/restriction pairs, and applies them in a boolean "AND" fashion, returning only dbrefs that fulfill all restrictions. See 'help @search' for information about them.
children() is exactly the same as lsearch(<me|all>,parent,<object>), using "all" for See_All/Search_All players and "me" for others.
nlsearch(...) and nchildren(...) return the count of results that would be returned by lsearch() or children() with the same args.
See 'help lsearch2' for more details.
If <class> is one of the eval ones (EVAL, EEXITS, EROOMS, EOBJECTS or EPLAYERS), note that any brackets, percent signs, or other special characters should be escaped, as the code in <restriction> will be evaluated twice - Once as an argument to lsearch(), and then again for each object looked at in the search.
<class> can be 'NONE' to make lsearch() act like a @search without a class.
lsearchr() is like an lsearch() run through revwords(). Results are returned from highest dbref to lowest. search() is an alias for lsearch().
Examples:
lsearch(all, flags, Wc) <-- lists all connected wizards.
lsearch(me, type, room) <-- lists all rooms owned by me.
lsearch(me, type, room, flag, W) <-- lists Wizard rooms owned by me.
lsearch(me, type, room, 100, 200) <-- same, but only w/db# 100-200
lsearch(all, eplayer, \[eq(money(##),100)\]) <-- lists all players with 100
coins.
This functions sets or clears flags on locks.
See 'help @lset' for more information on what flags are available.
This function returns the breakdown of objects in the database, in a format similar to "@stats". If <player> is "all", a breakdown is done for the entire database. Otherwise, the breakdown is returned for that particular player. Only wizards can LSTATS() other players. The list returned is in the format: <Total objects> <Rooms> <Exits> <Things> <Players> <Garbage>
stats() is an alias for lstats().
Takes two numbers, and returns 1 if and only if the first is less than the second, and 0 otherwise.
Takes two numbers, and returns 1 if and only if the first is less than or equal to the second, and 0 otherwise.
This function returns the dbrefs of all things, dark or not, in <object>. You must be in <object> or control it to use this function.
See also:
This function returns the dbrefs of all objects that are inside <object> and visible (non-dark). You must be in <object> or control it to use this function.
See also:
This function returns the dbrefs of all visible (non-dark) exits from <room>. You must be in the room or control it to use this function.
See also:
This function returns the dbrefs of all connected and non-dark players in an object. You must be in the object or control it to use this function.
This function returns the dbrefs of all non-dark things inside an object. You must be in the object or control it to use this function.
lwho() returns a list of the dbref numbers for all currently-connected players. When mortals use this function, the dbref numbers of DARK wizards or royalty do NOT appear on the dbref list.
If lwho() is given an argument, and used by an object that can see DARK and Hidden players, lwho() returns the output of lwho() from <viewer>'s point of view.
lwohid() returns a list of objid's instead.
Generated at Mon Jul 2 00:35:04 2007