Help Entries starting with 'W'

• @wait[/until] <time>=<command_list>
• @wait <object>=<command_list>
• @wait[/until] <object>/<time>=<command_list>

The basic form of this command puts the command list (a semicolon-separated list of commands) into the wait queue to execute in <time> seconds. If the /until switch is given, the time is taken to be an absolute value in seconds, not an offset.

The second form sets up a semaphore wait on <object>. The enactor will execute <command_list> when <object> is @notified.

The third form combines the first two: the enactor will execute <command_list> when <object> is @notified or when <time> passes, whichever happens first.

More forms that support semaphores on arbitrary attributes are described in "help @wait2".

Normally, a semaphore wait depends on the SEMAPHORE attribute of the object in question. However, it is useful to be able to use other attributes as semaphores, so one object can be used as the blocker for multiple different things at once. Possible attribute names aren't completely arbitrary. See "HELP SEMAPHORES5" for details.

The syntax for these are:

@wait <object>/<attribute> = <command list> @wait[/until] <object>/<attribute>/<time> = <command list>

You cannot do a non-timed semaphore on an attribute with a numeric name, as that is taken as a timeout instead.

• @wall[/<switch>] <message>

  Only wizards can use this command, which allows the player to shout
  or pose a message to every player connected. It must be typed in full.
  It can also take the following switches
  /emit    : emit a prefixed message to all.
  /noeval  : Don't evaluate the message.

You can also use @wall :<pose> to @wallpose.

• @warnings <object|me>=<warninglist>

If the building warning system is enabled, this command will set the types of warnings which should be reported on an object or to a player. You must control the object to use this command.

When an object is checked for warnings (via @wcheck by the owner, or automatically), only warnings which are set to be reported on the object will be reported. If no warnings are set on the object, the owner's warning settings will be used. When admin use @wcheck to check non-owned objects, their personal warnings are always used.

For a list of warnings, see 'help warnings list' See also 'help @wcheck' and 'help NO_WARN'

For examples, see 'help @warnings2'

Example 1: Normal building situations Most people will simply want to leave their @warnings set to "normal" and their objects' @warnings set to "none". They will then receive normal warnings for all their objects.

Example 2: Warning-lover People who find warnings very helpful (like heavy builders) may want to set their personal @warnings to "extra" or "all", and keep their objects' warnings at "none". If a specific object should be treated less strictly, set that object's @warnings differently. If an object shouldn't be warned on at all, set the NO_WARN flag on the object.

(continued in help @warnings3)

Example 3: Warning-hater People who prefer not to be warned except for specific object may set their personal @warnings to "none" and set the @warnings on those objects to appropriate levels.

Example 4: I need some peace! Players who @set themselves NO_WARN will receive no warnings ever until they unset the flag.

• @wcheck <object>
• @wcheck/all
• @wcheck/me

This command is enabled if the building warning system is enabled.

The first form of the command performs warning checks on a specific object. The player must own the object or be see_all. When the owner runs the command, the @warnings of the object are used to determine which warnings to give. If the object has no @warning's set, the @warnings of the owner are used. When a non-owner runs the command, the @warnings of the non-owner are used.

The second form of the command runs @wcheck on every object in the database and informs connected owners of warnings. It is usually automatically run by the MUSH at intervals. Only Wizards may use @wcheck/all.

The third runs it on all objects the player owns that aren't set NO_WARN.

• @whereis <player>

If <player> is not set UNFINDABLE, this command will tell you where the player is. It will also inform the player that you attempted to locate their position, and whether you succeeded or not.

To avoid being found this way, just do: @set me=UNFINDABLE

Ex: @whereis Moonchilde

• @wipe <object>[/<attributepattern>]

This command clears attributes from <object>, with the exception of attributes changeable only by wizards, and attributes not controlled by the object's owner (i.e. locked attributes owned by someone else). Only God may use @wipe to clear wiz-changeable-only attributes. The SAFE flag protects objects from @wipe.

If no <pattern> is given, this gets rid of all the attributes, with exceptions as given above. If <pattern> is given, it gets rid of all attributes which match that pattern. Note that the restrictions above still apply.

When wiping an attribute that is the root of an attribute tree, all attributes in that tree will also be removed.

• @wizmotd <message>

This is a wizard only command that will set a short temporary message that will be shown to all wizards when they connect. It is listed in @listmotd as the Wiz MOTD. A more permanent message can be set by the siteadmin by editing the file "wiz.txt".

• @wizwall[/emit] <message>

This wiz-only command works similarly to @rwall or @wall, sending a message in either say, pose, or emit format to all wizards who are currently logged in.

If the building warning system has been enabled in the source code, players may receive regular warnings about potential building problems on objects that they own, and will be able to check individual objects for warnings.

  For more information, see the following help topics:
    @warnings        @wcheck         NO_WARN         warnings list

The building warning system, if enabled, supports the following types of warnings:

  exit-unlinked         Warn on unlinked exits
  exit-oneway           Warn on exits with no return exit
  exit-multiple         Warn on multiple exits from A to B
  exit-msgs             Warn on missing succ/osucc/odrop/fail
  exit-desc             Warn on missing description
  room-desc             Warn on missing description
  thing-msgs            Warn on missing succ/osucc/odrop/fail
  thing-desc            Warn on missing description
  my-desc               Warn on missing player description
  lock-checks           Warn on @lock problems

(continued in help warnings list2)

These warnings combine the functionality of multiple warnings above:

  serious               exit-unlinked, thing-desc, room-desc, my-desc,
                        lock-checks
  normal                serious, exit-oneway, exit-multiple, exit-msgs
  extra                 normal, thing-msgs
  all                   all of the above

The warning "none" indicates no warnings. You can exclude warnings from a larger list by using !<warning> after the larger list. For example: @warnings me=all !exit-oneway

• where(<object>)

This function returns the "true" location of an object. This is the standard location (i.e. where the object is) for things and players, the source room for exits, and #-1 for rooms.

In other words, the "true" location of an object is where it is linked into the database. For example, an exit appears in the room of its "home", not its "location" (the LOC() function on an exit will return the latter). A room's "real" location is always Nothing (the LOC() function will return its drop-to).

whisper <player>=<message> whisper/silent <player>=<message> whisper/noisy <player>=<message> whisper/noeval <player>=<message> whisper/list <players>=<message>

Whispers the message to the named person, if they are in the same room as you. No one will see the message you whisper. 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.

In a noisy whisper, other players in the room may be told who you whispered to (but not what you whispered): Polgara whispers to Javelin. The probability that a noisy whisper will be heard aloud is configurable. In a silent whisper, other players will not know that you whispered. The default whisper may be configured either silent or noisy (check @config)

(continued in help whisper2)

The /noeval switch prevents any evaluation of the message, and is handy when you want to say things that use special characters like % or []'s.

The /list switch lets you whisper to many people at once. Multiple persons should be space-separated, and names with spaces should be enclosed in double-quotes.

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. Unlike most commands, it is case sensitive.

• width(<player|descriptor>[, <default>])
• height(<player|descriptor>[, <default>])

These two functions return the screen width and height for a connected player. If the player's client is capable of doing so, it will let the mush know what the correct sizes are on connection and when the client is resized.

The defaults are 78 for width, and 24 for height, the normal minimal values. These can be overridden when calling the function by providing the default to the function. Players can change the value that will be returned when the functions are called on them with the special SCREENWIDTH and SCREENHEIGHT commands, both of which take a number as their sole argument, and set the appropriate field.

When used on something that's not a visible player, the functions return the default values.

The intent of these functions is allow softcode that does formatting to be able to produce a display that can make full use of any given screen size.

PennMUSH has two standard wildcards in user-defined commands: an asterisk (*) matches any string, and a question mark (?) matches a single character. For example, let's say that you want a command called "supercalifragalisticexpealidocious" (don't ask me why), but you don't want to force people to type the whole thing to trigger the command. You could use a wildcard in the command trigger to match substrings of it:

&TOO_LONG_CMD object=$supercali*:@emit whee super > (nothing happens) supercali > whee supercalifra > whee supercalifragalisticexpealidocious > whee supercalifoobert > whee

A backslash (\) can be used to escape * and ? if you want to match a literal asterisk or question mark.

• wipe(<obj>/<attribute-pattern>)

This function is equivalent to @wipe. It returns nothing. Like @wipe, this function will destroy entire attribute trees; for more judicious deletion, use attrib_set().

with[/room] <obj>=<command>

Attempts to run a user-defined command on a specific object. If the /room switch is given, <obj> must be a room, and its contents are checked for commands as if it was a master room.

See 'help USER-DEFINED COMMANDS'.

  Flag:  WIZARD    (all types)

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.

Other objects may also be set WIZARD, and they then have all the powers of a Wizard except that they cannot @nuke players. Only Wizards may set the WIZARD flag on objects.

• wordpos(<list>, <number>[,<delimiter>])

Returns the number of the word within <list> 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"

• words(<list>[,<delimiter>])

words() returns the number of elements in <list>.

• wrap(<string>, <width>[, <first line width>[, <line separator>]])

This function takes <string> and splits it into lines containing no more than <width> characters each. If <first line width> is given, the first line may have a different width. If <line separator> is given, it is inserted between each line; by default the separator is a newline.

@desc here=[wrap(Wrapped paragraph,72)]
@desc here=[wrap([space(4)]Indented paragraph,72)]
@desc here=[iter(wrap(Hanging indent,72,76,|),
[switch(#@,>1,space(4))]##,|,%r)]