/#
/action
======
Format: /action {text pattern} {commands} {group name}

Action tells the client to look for a specific string of text from the mud and to execute a command or multiple commands when it finds it. Typing "/action" by itself will list all of the actions you have defined.

   {text pattern} This is the text to look for to trigger the action.
   {commands} The commands are the actions you want to take when the action is triggered.
   {group name} This is an optional parameter. See the user guide for help on groups.

/action {You are hungry.} {take food bag;eat food} 
This is the most basic form of an action. It sees the text "You are hungry." and then sends the commands "take food bag" and "eat food" to the mud.

/action {^You are hungry.} {take food bag;eat food} 
You can 'anchor' an action by starting it with a caret (^). When an action is anchored the text to search for must be at the beginning of the line.

/action {%0 looks at you.} {say Hi $0} 
%0-%9 are substitution variables that you can use in the trigger side of an action. They work like a wildcard character but store the text the wildcard represents for your use. If the mud sent the text "Arithon looks at you." it would send the command "say Hi Arithon" back. You can use up to 10 (0-9) of these variables to help you match a text pattern.
===
#/


/#
/alias
=====
Format: /alias {shortcut} {commands} {group name}

An alias lets you define some "shortcut" text to execute a command or commands. Your alias list is checked each time you press enter to send some text to the mud. If the text you typed is found in your alias list the text from the commands side of the alias is sent instead.  An alias is only replaced if it is the first text typed on a line.

   {alias name} This is the shortcut text you want to be able to type to execute commands.
   {commands} The commands to execute when the alias name is typed.
   {group name} This is an optional parameter. See the user guide on groups for help. 

/alias {eat} {take food bag;gobble food}
If you typed "eat" on the input line the commands "take food bag" and "gobble food" would be sent to the mud instead.

/alias {targ %0} {/var Target $0}
You can also use the variable %0 to represent the text typed after the alias shortcut. In this case the alias is used to quickly set a targeting variable. Typing "targ Vecna" would set a variable called "Target" to "Vecna"
===
#/

/#
/array
=====
Format: /array {array name} {rows} {group name}
Format: /array {array name} {rows,columns} {group name}

Array lets you create both single and two dimensional arrays. If you are not familiar with arrays, you can think of them like a spreadsheet. A single dimensional array would have only 1 column, and as many rows as you specify.
A two dimensional array would have both rows and columns. Each cell in the array would be accessed by giving a row and a column number. In the case of single dimensional array, only a row number is needed. Each cell can hold data like a variable.

   {array name} The name of the array.
   {rows} When creating a single dimensional array, the number of rows. The number must be between 1 and 100.
   {rows,columns} For creating a two dimensional array. The numbers must be between 1 and 100.
   {group name} This is optional, see the user guide for help with groups.

/array {Targets} {3}
This would create an array called Targets. The array can hold up to 3 items.

/array {Grid} {5,5}
This creats a two dimensional array, or a grid. The grid has 5 rows, with 5 columns in each row.
===
#/

/#
/assign
======
Format: /assign {array name} {row} {value}
Format: /assign {array name} {row,column} {value}

Assign sets the value of a cell in an array.

   {array name} The name of the array.
   {row} For assigning cells in a single dimensional array. The number must be between 1 and the number of rows you created the array with.
   {rows,columns} For assigning cells in a two dimensional array. The numbers must be between 1 and the number of rows and columns you created the array with.
   {value} The text or number you want to assign to the cell.

/assign {Targets} {1} {Soth}
This assigns the first cell in the array to hold the text "Soth".

/assign {Grid} {2,4} {16}
This assigns row 2, column 4 of the grid with a value of 16.
===
#/

/#
/autoaccept
==========
Format: /autoaccept
Format: /autoaccept {on/off}

When a chat call comes in if AutoAccept is on you are not prompted to accept the call. AutoAccept without parameters toggles the option between on and off.

   {on/off} Sets the option on or off.
===
#/

/#
/barback
=======
Format: /barback {color}

Changes the background color of the status bar.
   {color} Can be between 0 and 7.
===
#/

/#
/barfore
=======
Format: /barfore {color}

Changes the foreground color of the status bar.
   {color} Can be between 0 and 15.
===
#/

/#
/baritem
=======
Format: /baritem {item name} {text to print} {position} {max length} {fore color} {back color} {group}

BarItem adds text to the status bar.

   {item name} identifies the item which you can later use to enable or disable, modify or delete the item later.
   {text to print} is the text you want displayed on the status bar. This can either be literal text, or it can be a variable or procedure.
   {position} is the column position you want the item to start printing at on the bar. The position must be a number between 1 and 80.
   {max length} is the maximum number of characters you want this item to display. If the text to be printed is longer than the max length, it will be truncated. This prevents items from printing over the top of neighboring items.
   {fore color} Items can have colors separate from the status bar. This can be a number from 0 to 15. If you leave both the fore color and the back color at 0, it will use the color of the status bar. This parameter is optional and will default to 0 if you don't specify it.
   {back color} The background color of the item. Can be a number from 0 to 7. This parameter is optional and will default to 0 if you don't specify it.
   {group} Optional parameter. See the user guide on grouping.

You are responsible for making sure your bar items do not overlap. If you create two bar items that start at position 1,one of them will be overwritten.

/baritem {Target} {$Target} {1} {12} {11} {0}
This will create an item called Target. It will display the value of the variable $Target. It will start at position 1, have a maximum length of 12. It will use foreground color 11, and back ground color 0.

/baritem {Target} {$Target} {1} {12}
This creates the same thing as above. The colors have not been specified, so it will default to using the colors of the status bar.
===
#/

/#
/baritemback
===========
Format: /baritemback {item name} {color}

Changes the background color of a bar item.

   {item name} Name of the bar item which you want to change the color of.
   {color} A number between 0 and 7.
===
#/

/#
/baritemfore
===========
Format: /baritemfore {item name} {color}

Changes the foreground color of a bar item.

   {item name} Name of the bar item which you want to change the color of.
   {color} A number between 0 and 15.
===
#/

/#
/baritemshift
============
Format: /baritemshift {start item} {end item} {number}

BarItemShift allows you to shift items on the statusbar to the left or right without having to hand edit all the positions.

   {start item} The number of the first item you want to shift.
   {end item} The number of the last item you want to shift.
   {number to shift} If you put a positive number here all the items will be shifted to the right that many character places. If you put a negative number, they will all be shifted left.

/baritemshift 1 3 5
This will shift the items 1 through 3 five places to the right.
===
#/

/#
/barseparator
============
Format: /barseparator {item name} {position}

BarSeparator lets you add a separator character into the status bar; which is a vertical bar.

   {item name} Gives the separator a name so it can be edited, disabled, enabled or removed.
   {position} The character position on the status bar you want the separator to appear. The position must be between 1 and 80.

/barseparator {Targ Sep} {15}
This will add a separator as position 15 in the statusbar.
===
#/

/#
/bell
====
Format: /bell

Makes your computer speaker beep.
===
#/

/#
/call
====
Format: /call {address} {port}

Call establishes a link with another user using Mud Master. Once you are connected with another user you can chat, transfer commands and transfer files. The number of people you can be connected to at one time is limited only by the number of socket connections windows will let you have.

   {address} The address of the person you wish to call. This can be either a named address or an IP address.
   {port} The port is optional. If you don't specify a port number Mud Master will use a default of 4050.
===
#/

/#
/calldll
=======
Format: /calldll {dll name} {Function Name} {Parameters to Send}

This command is used to call functions in a user defined DLL.

   {dll name} - The name of a loaded DLL to call.
   {Function Name} - The name of a function to call in the DLL.
   {Parameters to Send} - Information to send to the DLL function. Variables, functions, etc... are translated before being sent to the DLL.

/calldll {MyDLL} {MyFunction} {Some text to send and a variable $Var}
This will call the function "MyFunction" defined in the DLL "MyDLL" and send the text "Some text..."
===
#/

/#
/chatgroup
=========
Format: /cg {groupname} {text}
Format: /chatgroup {group name} {text}

ChatGroup sends text to all the chat connections with a specific group name.

   {group name} The name of the group you wish to chat to.
   {text} The text to send to the group.
===
#/

/#
/chat
====
Format: /chat
Format: /chat {chat name} {text}
Format: /chat {reference number} {text}

Chat has two purposes. Without parameters it lists all the chat connections you currently have. It is also used to chat privately with another user.

   {chat name} The chat name of the person you want to send some text to.
   {reference number} The number of the person you want to send some text to. The number is from the list of chat connections.
   {text} The text to send.

/chat 
Displays all the chat connections you have.

/chat bosozoku Heya Boso!
Sends a private chat of "Heya Boso!" to Bosozoku.

/chat 1 Hi.
Sends a private chat of "Hi." to the first connection in your chat list.
===
#/

/#
/chatall
=======
Format: /chatall {text}

Sends text to all of your chat connections.

   {text} The text to send.
===
#/

/#
/chatback
========
Format: /chatback {color}

Changes the background color of the chat text.

   {color} Can be between 0 and 7.
===
#/

/#
/chatcommands
============
Format: /chatcommands {reference number}
Format: /chatcommands {chat name}

ChatCommands is a toggle that enables or disables the ability for a chat connection to send you commands. You can see if a connection has command sending enabled by looking at /chat. You will see an A flag if the option is enabled. Once enabled the other person can send you commands (actions, aliases, events, etc...).

   {reference number} The number of the chat connection to toggle.
   {chat name} The chat name of the chat connection to toggle.
===
#/

/#
/chatfore
========
Format: /chatfore {color}

Changes the foreground color of the chat text.

   {color} Is a number between 0 and 15.
===
#/

/#
/chatgroup
=========
Format: /cg {groupname} {text}
Format: /chatgroup {group name} {text}

ChatGroup sends text to all the chat connections with a specific group name.

   {group name} The name of the group you wish to chat to.
   {text} The text to send to the group.
===
#/

/#
/chatgroupremove
===============
Format: /chatgroupremove {reference number}
Format: /chatgroupremove {chat name}

Removes the group name from a chat connection.

   {reference number} The number of the chat connection you want to change.
   {chat name} The name of the chat connection you want to change.
===
#/

/#
/chatgroupset
============
Format: /chatgroupset {reference number} {group name}
Format: /chatgroupset {chat name} {group name}

Assigns a group name to a chat connection.

   {reference number} The number of the chat connection you want to change.
   {chat name} The name of the chat connection you want to change.
===
#/

/#
/chatignore
==========
Format: /chatignore {reference number}
Format: /chatignore {chat name}

ChatIgnore toggles the ignore flag of a chat connection. In the /chat list you will see an I flag when you are ignoring a connection. While a connection is being ignored, you will not see any text or name changes from that connection.

   {reference number} The number of the chat connection you want to change.
   {chat name} The name of the chat connection you want to change.
===
#/

/#
/chatignoreall
=============
Format: /chatignoreall

Blocks incoming /chatalls.  You will still be able to see private chats and group chats.  Being a chat server is pointless with this option on.
===
#/

/#
/chatname
========
Format: /chatname {name}

Sets your chat name. You must set a chat name before you can make any chat calls.

   {name} The name you wish to be known by.
===
#/

/#
/chatprivate
===========
Format: /chatprivate {reference number}
Format: /chatprivate {chat name}

ChatPrivate toggles the Private flag of a chat connection. Private connections are not returned when somebody requests your connections.
   {reference number} The number of the chat connection you want to change.
   {chat name} The name of the chat connection you want to change.
===
#/

/#
/chatserve
=========
Format: /chatserve {reference number}
Format: /chatserve {chat name}

ChatServe toggles the Serve flag of a chat connection. When you serve a chat connection any /chatalls from that person are sent out to all of your other connections. Likewise, when text comes in from any of your other connections, it is sent to anybody being served. This would allow two people who are both firewalled to still communicate with each other as long as they connected with another person who can connect to the both of them.

   {reference number} The number of the chat connection you want to change.
   {chat name} The name of the chat connection you want to change.
===
#/

/#
/chattransfers
=============
Format: /chattransfers {reference number}
Format: /chattransfers {chat name}

ChatTransfers toggles the Transfer flag of a chat connection. Once a connection has been set with the transfer flag that person is allowed to send you files.

   {reference number} The number of the chat connection you want to change.
   {chat name} The name of the chat connection you want to change.
===
#/

/#
/chatversions
============
Format: /chatversions

Shows you the version of Mud Master your chat connections are using.
===
#/

/#
/clearlist
=========
Format: /clearlist {list}

Removes all the items from a list.
===
#/

/#
/cr
==
Format: /cr

Sends a carriage return to the mud.
===
#/

/#
/debug
=====
Format: /debug

Toggles debug messages on and off.
===
#/

/#
/debugdepth
==========
Format: /debugdepth {steps}

The number of steps to print out when you hit an error. Set it to 0 if you don't want to see the debug info.  Defaults to 10.
===
#/

/#
/default
=======
Format: /default {file name}

Default tells Mud Master which command file you want loaded for you automatically when you first start it up.

   {file name} The name of the command file to load.
===
#/

/#
/dir
===
Format: /dir {file mask} {result list}

Dir fills a list with all the files matching the file mask.

   {file mask} - Path and wildcard characters of files to find.
   {result list} - The name of a list to fill with the results. If the list doesn't already exist it will be created.

/dir {*.*} {DirList}
Fills a list named DirList with all the files in the Mud Master directory.
===
#/

/#
/disable...
==========
Format: /disableaction {trigger}
Format: /disableaction {reference number}
Format: /disablealias {alias name}
Format: /disablealias {reference number}
Format: /disablebaritem {item name}
Format: /disablebaritem {reference number}
Format: /disableevent {event name}
Format: /disableevent {reference number}
Format: /disablegag {trigger}
Format: /disablegag {reference number}
Format: /disablegroup {group name}
Format: /disablehighlight {trigger}
Format: /disablehighlight {reference number}
Format: /disablemacro {macro name}
Format: /disablemacro {reference number}
Format: /disablesubstitute {trigger}
Format: /disablesubstitute {reference number}

Disablexxx allows you to turn individual commands off. You can see which commands you have disabled when you list all of your defined commands. Disabled commands will have an asterisk right after their reference number.

/disablegroup {groupname} will disable all commands in the group.
===
#/

/#
/disconnect
==========
Format: /disconnect

When using Mud Master in direct modem mode this attempts to hang up the line.
===
#/

/#
/dll
===
Format: /dll

Shows all the user defined DLLs you have loaded.
===
#/

/#
/dnd
===
Format: /dnd

DND stand for Do Not Disturb. This command toggles DND on and off. When DND is on, chat connections are automatically refused.
===
#/

/#
/doevents
========
Format: /doevents

Toggles the processing of events on and off.
===
#/

/#
/downloadpath
============
Format: /downloadpath {directory}

Sets a directory to use for files downloaded with chat.
===
#/

/#
/echoactions
===========
Format: /echoactions

Toggles the ability to see what commands MM is sending when it fires off an action. Defaults to on.
===
#/

/#
/emote
=====
Format: /emote {chat name} {text}
Format: /emote {reference number} {text}

Emote send an emote to a specific chat connection.

   {chat name} The chat name of the person you want to emote to.
   {reference number} The number of the person you want to emote to.
   {text} The text to emote.

/emote 1 hugs you.
Chat connection 1 would see "<ChatName> hugs you." 
===
#/

/#
/emoteall
========
Format: /emoteall {text}

Sends an emote to all of your chat connections.

  {text} The text to send.
===
#/

/#
/emotegroup
==========
Format: /emotegroup {group name} {text}

EmoteGroup sends an emote to all the chat connections with a specific group name.

   {group name} The name of the group you wish to emote to.
   {text} The text to send to the group.
===
#/

/#
/empty
=====
Format: /empty {variable name}

Empty creates a variable with an empty string (a string with no data in it).

   {variable name} The name of the variable to create or set to empty.
===
#/

/#
/enable...
=========
Format: /enable[commandtype] {trigger or item name}
Format: /enable[commandtype] {reference number}
Format: /enablegroup {group name}

Enable is the opposite of /disable... See help on "/disable..." to see a list of command formats.

/enablegroup {group name} will turn on all commands in the group.
===
#/

/#
/event
=====
Format: /event {name} {frequency} {event actions} {group}

Event causes some actions to be taken when a certain amount of time has passed. {frequency} is the amount of time in seconds to pass before firing the event. You can create as many events as you like.  Duplicate frequencies are valid; so you could create several events to fire every 10 seconds.

   {name} The name of the event.
   {frequency} The number of seconds until the event fires.
   {event actions} The commands to do when the event fires.
   {group} Optional, see the user guide for help on groups.

Typing /event by itself will list all the events you have defined. When you list the events you are also shown the time left before the event fires.

001: {Jumper} {F:30} {T:14} {jump}
This is an example of an event listing. This first parameter is the name of the event.  F: shows you the frequency you have set for the event.  T: shows how much time is left before the event gets fired. The last part contains the event actions to be taken when the event is fired.

/event {Jumper} {30} {jump}
This will create an event called Jumper that jumps every 30 seconds.
===
#/

/#
/filecancel
==========
Format: /filecancel {reference number}
Format: /filecancel {chat name}

FileCancel cancels a file transfer that is in progress. When a file is cancelled it is not removed from your system. If you don't want the partial file around you will have to delete it yourself.

   {reference number} The number of the chat connection where the file transfer is in progress.
   {chat name} The name of the chat connection where the file transfer is in progress.
===
#/

/#
/fileDelete
==========
Format: /filedelete {filename}

Deletes a file.

   {filename} - Full path and filename of a file to delete.
===
#/

/#
/filestatus
==========
Format: /filestatus {reference number}
Format: /filestatus {chat name}

FileStatus shows you the progress of a current file transfer. The name of the file, the file size and the bytes transferred are shown.

   {reference number} The number of the chat connection where the file transfer is in progress.
   {chat name} The name of the chat connection where the file transfer is in progress.
===
#/

/#
/fireevent
=========
Format: /fireevent {event number}
Format: /fireevent {event name}

FireEvent causes an event to be fired before the time has elapsed. This also resets the time elapsed to 0 for this event.

   {event number} The number of the event to fire.
   {event name} The name of the event to fire.

/fireevent 1
Would fire the first event in the event list. Also the time elapsed is set back to 0.
===
#/

/#
/freelibrary
===========
Format: /freelibrary {dll name}

Removes a user defined DLL from memory.

   {dll name} - Name of the user defined DLL.
===
#/

/#
/gag
===
Format: /gag {mask}

Adds a gag to the gag list. Before the client prints a line of text to the screen it checks the gag list. If {mask} is found in a line of text that line will not be printed.

   {mask} This is the text pattern to search for to determine what lines of text to gag. The mask can be defined the same way you define the text pattern for an action-- using %0 through %9.

/gag {Geoff says}
Any lines that have the text "Geoff says" in them will not be seen.

/gag {You hear %0 shout}
Any lines that have the text "You hear <name> shout" will not be seen.
===
#/

/#
/highlight
=========
Format: /highlight {mask} {foreground color, background color}

Adds a highlight to the highlight list. Before the client prints a line of text to the screen it checks the highlight list. If {mask} is found in a line of text the colors for that word or words are changed to colors that you specify.

   {mask} This is the text pattern to search for to determine what lines of text to highlight. The mask can be defined the same way you define the text pattern for an action-- using %0 through %9. If the mask does not contain any wildcards (%0 - %9) then just the word is highlighted. If the mask uses a wildcard, the whole line is changed to the color.
   {color,color} The foreground and background color to change the text to. Valid color names are in the table below. If you don't specify a background color "back black" will be used.

Color Names
   Foreground Colors:
     black, blue, green, cyan, red, magenta, brown, light
     grey, dark grey, light blue, light green, light cyan, light
     red, light magenta, yellow, white

   Background Colors:
     back black, back blue, back green, back cyan, back
     red, back magenta, back brown, back light grey

/highlight {disarms you} {yellow}
Any time you see the text "disarms you" it will appear in yellow.

/highlight {You hear %0 shout} {white,back blue}
Since a wildcard was used in the mask, when the text is found the entire line will be changed to white on blue.
===
#/

/#
/if
==
Format: /if {conditional statement} {then} {else}

If commands need to be activated in some fashion in order to be evaluated. Most commonly you would place an if command inside an action. However, they could also be place inside an alias or macro. The if command has been modeled after an if statement in C.

   {conditional statement} This is a statement that evaluates to either true or false. Any statement evaluating to a 0 is considered false, while any other result would be considered true.
   {then} The commands you place here will be executed if the condition is evaluated to true.
   {else} The commands you place here will be executed if the condition is evaluated to false. This paramater is optional. 

Operators recognized by if:

   Operator   Description               Operator   Description
   --------   ---------------------     --------   ------------------------
   &&         And                       ||         Or
   ==         Equal To                  =          Equal To
   !=         Not Equal To              >          Greater Than
   <          Less Than                 >=         Greater Than or Equal To
   <=         Less Than or Equal To     ()         Precedence

Operators are evaluated in this order: (), &&, ||, =, ==, !=, >, <, >=, <=.

/action {^You are hungry.} {/if {$AutoEat = 1} {take food bag;eat food}}
The above would allow you to turn eating on and off. You need to define a variable called AutoEat and give it a value of 1 when you want eating to be automatic, and any other number when you want to turn it off. 

/action {%0 enters the room.} {/if {$MeanMode = 1 && $0 = "Atlas" || $0 = "Breedan"} {spit $0}}
Assuming the mud sent the text "<character name> enters the room." each time somebody entered the room. Each time somebody enters the room the client would check to see if MeanMode is 1, and that the name of the person who entered is either Atlas or Breedan, and if it is, would spit on them.===
#/

/#
/itemadd
=======
Format: /itemadd {listname} {item text}
Format: /itemadd {list number} {item text}

Adds a text string to a user defined list.

   {list name} The name of the list to add the item to.
   {list number} The number of the list to add the item to.
   {item text} The text to add to the list.
===
#/

/#
/itemdelete
==========
Format: /itemdelete {list name} {item text} 
Format: /itemdelete {list name} {item number} 
Format: /itemdelete {list number} {item text} 
Format: /itemdelete {list number} {item number}

Deletes an item from a user defined list.

   {list name} The name of the list to delete the item from.
   {list number} The number of the list to delete the item from.
   {item text} The text of the item to delete.
   {item number} The number of the item to delete.
===
#/

/#
/killall
=======
Format: /killall

Removes all your stored commands from memory (aliases, actions, events, etc...).
===
#/

/#
/killgroup
=========
Format: /killgroup {group name}

Removes all the stored commands from memory that belong to a certain group (aliases, actions, events, etc...).

   {group name} The name of the group you want to remove.
===
#/

/#
/listadd
=======
Format: /listadd {list name} {group name}

Creates a new user defined list.

   {list name} Name of the list you want to create.
   {group name} Optional, see the user guide for help on groups.
===
#/

/#
/listdelete
==========
Format: /listdelete {list name}
Format: /listdelete {list number}

Deletes a user defined list and any items in the list.

   {list name} The name of the list you want to delete.
   {list number} The number of the list you want to delete.
===
#/

/#
/listitems
=========
Format: /listitems {list name}
Format: /listitems {list number}

Displays all the items in a particular list.

   {list name} The name of the list of items you want to see.
   {list number} The number of the list of items you want to see.
===
#/

/#
/lists
=====
Format: /lists

Displays all the user lists you have defined and how many items are in each list.
===
#/

/#
/loadlibrary
===========
Format: /loadlibrary {dll name}

Loads a user defined DLL.

   {dll name} - Path and file name of the DLL to load.
===
#/

/#
/logclose
========
Format: /logclose

If you are currently logging your session to a file, this closes the log file.
===
#/

/#
/logopen
=======
Format: /logopen {filename}

Opens a log file. Everything seen on the terminal screen is written to this file.

   {filename} The name of the file you want to use for logging your session.
===
#/

/#
/logopenappend
=============
Format: /logopenappend {filename}

Starts logging to a file. This function adds the log text to the end of an already existing file. Use /logopen if you want to replace the text in the log file.
===
#/

/#
/logstatus
=========
Format: /logstatus

If a log file is open this shows the name of the file current being logged to and how many bytes have been written.
===
#/

/#
/loop
====
Format: /loop {start,end} {commands}

Loop increments or decrements a number from start to end. Each time the number is incremented or decremented the commands are executed. The loop number is placed in the system variable $LoopCount.

   {start,end} The start and ending numbers for the loop. If start is bigger than end, the loop will count backwards.
   {commands} The commands to execute for each count of the loop.

/loop {1,3} {look $LoopCount.man}
This would send the text "look 1.man" "look 2.man" and "look 3.man" to the mud.

/loop {3,1} {look $LoopCount.man}
This does exactly the opposite. The number is decremented rather than incremented and would send the text: "look 3.man" "look 2.man" "look 1.man"
===
#/

/#
/macro
=====
Format: /macro {key name} {commands} {group name}

   {key name} The name of the key and any modifiers(control, alt, delete) you want to apply to it.
   {commands} The commands to execute when the macro key is pressed.
   {group name} Optional, see the user guide for help on groups.

Lets you assign a command or multiple commands to a key. When you press the key, the client processes the commands. The keyname is the name of the key, or the name of a key prefixed with a modifier. Their are two ways to change the behavior of a macro:

   1) Place a semi-colon as the last character in the commands section.
      Instead of automatically processing the text in the macro the
      text is instead inserted into the input bar. 
   2) Place a colon as the last character in the commands section. The
      text of the macro is insterted into the input bar with a carriage
      return.

Certain keys cannot be assigned as macro keys (they are used by the client):

   alt-uparrow 
   home 
   end 
   regular ascii characters, or shifted ascii characters 
   arrow keys 
   control-left arrow or control-right arrow 
   ctrl-x 
   ctrl-c 
   ctrl-] 

Special key names:

   Function Keys: f1 - f12 
   Delete: del 
   Keypad Delete: kpdel 
   Keypad Characters: kp0 - kp9 
   Insert: ins 
   Home: home 
   Page Up: pgup 
   Page Down: pgdn 
   End: end 
   Up Arrow: uparrow 
   Down Arrow: dnarrow 
   Right Arrow: rtarrow 
   Left Arrow: ltarrow 
   Keypad Star: kpstar 
   Keypad Plus: kpplus 
   Keypad Minus: kpminus 
   Keypad Slash: kpslash 

Key modifiers let you specify whether the control, alt or shift keys are being pressed. The order you use the modifiers is not important. Modifers must prefix the keyname.

   Alt: a 
   Shift: s 
   Control: c 

/macro {f1} {take food bag;eat food}
This is the most basic form of a macro. You press it, it does it. 

/macro {f1} {backstab ;}
Ending a macro with a semi-colon causes the text to appear in the input bar instead of automatically processing it. Pressing F1 with this macro will insert "backstab " where the cursor is. 

/macro {f2} {Arithon:}
Ending a macro with a colon will insert the text into the input bar at the cursor position and then press enter for you. A use for this would be to combine several macros onto the input bar and have the final macro press enter for you. If you were to press F1 from the above example then press F2 it would send to the mud "backstab Arithon" 

/macro {sf1} {cast create food}
This macro has a modifier in front of the key name; which creates the macro Shift-F1. 

/macro {ascf1} {cast create food}
Creates the macro Alt-Shift-Control-F1 

/macro {ab} {bs $Target}
Creates the macro Alt-B
===
#/

/#
/math
====
Format: /math {variable for result} {math expression}

The math command lets you perform mathematical equations and place the result in a variable. Math does integer math only (no floating point).

   {variable for result} The name of the variable to place the result in. If the variable doesn't exist it will be created.
   {math expression} Mathematical expression to be evaluated. 

Operator  Description
--------  -----------
()        Precedence
*         Multiplication
/         Division
%         Modulus
+         Addition
-         Subtraction

Anything enclosed in the parens will be evaulated first. Then all the multiplication, division and modulus operators are evaulated left to right. Then addition and subtraction are evaluated left to right.

/math {result} {3 + 5 * 4} 
Would place the number 23 in a variable called "result." 

/math {result} {(3 + 5) * 4} 
Would place the number 32 in a variable called "result." 

/math {result} {$Result + 1} 
Adds 1 to variable "result." 

/math {result} {5 % 3} 
The modulus operator returns the remainder of a division as an integer. This would place the number 2 in the variable "result." 5 divided by 3 leaves a remainder of 2.
===
#/

/#
/message
=======
Format: /message {message type}

When the alias, action, tab completion, variable or macro list is changed in any way the client prints a message to the terminal screen letting you know about it. You can toggle these messages on or off with this command.

   {message type} The type of messages to turn on or off. The valid message types are: actions, aliases, bar items, events, list, macros, tablist, variables.
===
#/

/#
/notifydll
=========
Format: /notifydll {type of notification} {dll} {Dll function name}

Instructs MM to call a specific DLL function when certain events happen in MM.

Each of the notification types must have the DLL function delcared in the following way. A list of parameters they take is as follows. None of the notification functions have a return buffer.  If you want to take an immediate action you must use the callback interpreter pointer.

You can use /notifydll {type} to list all the notifications that are in use for that type.

   Notification Type:
      Connected - 
         Params: (SOCKET hSocket)
         Return: void
         When a connection to the mud is made.

      Disconnected - 
         Params: (void)
         Return: void
         When your connection to the mud is lost.

      ChatConnect - 
         Params: (SOCKET hSocket, const char *pszChatName)
         Return: void
         When a chat connection is established.  Regardless of whether
         you initated the chat or it was an answered incoming.

      ChatDisconnect - 
         Params: (SOCKET hSocket, const char *pszChatName)
         Return: void
         Whenever you lose a chat connection.  The socket is passed in
         here for reference only.  The socket has already been
         disconnected and no socket operations should be preformed on
         it.

      Input -
         Params: (const char *pszInput)
         Return: BOOL
         When the user presses enter on the input bar.  Return TRUE if
         you process the line and don't want MM to process it as well.
         Return FALSE mm will process the line.  Be careful of this one
         it -- if you return TRUE the client will never process the
         line.  This can make it so the user can never give commands to
         the client.

      Raw -
         Params: (char *pszBuf)
         Return: BOOL
         This is the data received from the socket before MM does
         anything to it.  If you return TRUE, it means the DLL took
         care of processing the data and MM will ignore it. If you
         modify the buffer just make sure you NULL terminate it.
===
#/

/#
/pace
====
Format: /pace {number of milliseconds}

Pace controls has fast commands are sent to the mud when you are speedwalking.

   {number of milliseconds} The number of milliseconds to wait before sending the next movement command. 

For those of you not metrically aware 1000 milliseconds is equal to 1 second. 500 milliseconds is half a second, etc...
===
#/

/#
/peekconnections
===============
Format: /peekconnections {chat name}
Format: /peekconnections {chat number}

   {chat name} - Name of the chat connection you wish to peek at.
   {chat number} - Number of the chat connection you wish to peek at.

This command will return you a list of connections another chat user has. This is very similar to request connections except it will not try to connect you to all of the returned connections.
===
#/

/#
/ping
====
Format: /ping {chat name}
Format: /ping {chat number}

   {chat name} - Name of the chat connection you wish to ping.
   {chat number} - Number of the chat connection you wish to ping.

Gives you the latency time of a chat connection.
===
#/

/#
/playmidi
========
Format: /playmidi {filename}

   {filename} - Name of the midi file to play.

Plays a MIDI file. The music file must be in the directory specified with /soundpath. If you have not set a sound path the file must be in the Mud Master directory.
===
#/

/#
/playwav
=======
Format: /playwav {filename} [{LeftVol,RightVol} or {Volume}] {Priority}

PlayWav lets plays a waveform sound file.

   {Filename} Sound file to play.
   {LeftVol,RightVol} Set the volume levels for left and right channels.
      ..OR..
   {Volume} Set volume (all channels) (I believe values are 1-100 for volume levels (percent of max), ...Oma)
   {Priority} (Oma editing here..) If I recall this allows you to specify which sounds take precidence. I think the values are 1-100. A Priorty of 100 would force itself to play over any sound with a lower priority. Handy if you're max'd out on resources and you need a particular sound(s) to play (overriding other current sounds).
===
#/

/#
/presubstitute
=============
Format: /presubstitute

When on, substitutes are processed before the actions are checked. When off actions are processed on the original text.
===
#/

/#
/promptoverwrite
===============
Format: /promptoverwrite

Toggles prompting before overwriting a command file with /write.

Tip: A handy command, useful for scripts that save to file, you can toggel prompt off to avoid the pause "Overwrite this file..?" and just force instant overwriting. --Oma
===
#/

/#
/read
====
Format: /read {filename}

Reads a saved command file.

   {filename} Name of the command file to read in.
===
#/

/#
/requestconnects
===============
Format: /requestconnects {reference number}
Format: /requestconnects {chat name}

RequestConnects will return all the public connections of another chat user. When the connections are returned Mud Master will call them all and attempt to connect you to them. This is useful for joining a group of people on chat without having to individually call each of the people.

   {reference number} The number of the chat connection you want to request connections from.
   {chat name} The name of the chat connection you want to request connections from.
===
#/

/#
/resetevent
==========
Format: /resetevent {event number}
Format: /resetevent {event name}
Format: /resetevent *

ResetEvent causes the time elapsed for an event to be reset back to 0. If instead of passing an event number you pass an asterisk instead, all events will be reset. You might want to reset all events if you are trying to get several events to fire at the same time. If you define two events, each to fire every 10 seconds they are most likely not going to fire at exactly the same time (since created them at different times). If you reset all the events they would both be reset to fire in 10 seconds and would fire at the same time from then on.

   {event number} The number of the event you want to reset.
   {event name} The name of the event you want to reset.
   * Will reset all events.
===
#/

/#
/savescrollback
==============
Format: /savescrollback {file name}

Saves the scrollback buffer to a text file.

   {file name} File to save the scrollback buffer to.
===
#/

/#
/send...
=======
Format: /send[command] {chat name} {reference number}
Format: /send[command] {chat name} {trigger or name}
Format: /send[command] {chat reference number} {reference number}
Format: /send[command] {chat reference number} {trigger or name}

Send[command] sends one of your commands to another chat user.

   [command] = action, alias, array, baritem, event, gag, highlight, list, macro, substitute, and variable. eg: /sendaction {Joe} {10} sends your 10th action to Joe.
   {chat name} The chat name of the person you want to send to.
   {chat reference number} The number of the person you want to send to.
   {reference number} The number of the action you want to send.
   {trigger text} The action you want to send.

**Sending grouped commands:**
/sendgroup... will send all commands in a group.

**Sending a File:**
Format: /sendfile {chat name} {filename}
Format: /sendfile {chat reference number} {filename}
  The {filename} is the full path to the file, or if you have upload path set, you can use just the filename and it will look for that file in your upload dir.


Oma's Tip: Sending huge commands can result in the receiver getting a broken command (the amount sent exceeded the packet size, and the command gets cut short). This typically happens with big lists and arrays. The best method to send a huge command, list, or array is to first write that command/list/array to a file, then use /sendfile. The recieving user gets the file, then they simply /read that file into mm.
===
#/

/#
/session
=======
Format: /session {session name} {network address} {port}

This is the command you use to create a connection to the mud.

   {session name} The name of the session you want to start. This is not use anywhere at the moment and is just included to be compatible with tintin. It is still a required parameter.
   {netword address} The address of the mud. This can be in either IP formation, or a named address.
   {port} The port you want to connect to. 

Example:
   /sesion med medievia.com 4000
===
#/

/#
/seteventtime
============
Format: /seteventtime {event name or number} {new time}

Changes the frequency of which an event fires. It also resets the time elapsed.
===
#/

/#
/showme
======
Format: /showme {text}

Showme will echo the text to the terminal screen. The text is not sent to the mud.

{text} Text to display.

Oma's Tip: Showme will still handle variables and procs imbedded in the showme text. Use backslash to null out key MM events. eg: /showme {My email address is tard\@lick.com. It costs me \$@Math($MyAllowance*4) a month for this account}
..you'd see: tard@lick.com and "$20" (assuming MyAllowance = 5, which it does!)
===
#/

/#
/showmismatcherrors
==================
Format: /showmismatcherrors

Toggles the showing of mismatch scripting errors.

Mismatch errors are reported when you try to compare a string with a number in an /if statement. There are some places you can't avoid getting them - like using a wildcard variable in an action, then comparing that variable. Sometimes the wildcard is a number, sometimes a string, which causes a mismatch error. It is still an error, but acceptable in these cases.  A mismatch error will ALWAYS cause the condition to evaluate to to 0 (FALSE). I made this a setting so you can still use it to debug scripts, but can turn it off the rest of the time. It is off by default.
===
#/

/#
/speedwalk
=========
Format: /speedwalk {on/off}

When speedwalking is on anytime you send a line of text that contains only movement characters (n, s, e, w, u and d) the client will send the commands one at a time at a speed determined by the /pace command. If you typed "nnnuws" the client would walk you north 3 times, up once, west once and finally south.
===
#/

/#
/statusbar
=========
Format: /statusbar {position}

Toggles the statusbar on and off.

   {position} Can be either "above" or "below". Defines whether you want the status bar above the input line or below it.
===
#/

/#
/substitute
==========
Format: /substitute {text pattern} {replacement text} {group name}

A substitute looks for text patterns in the same way that an action does. When it finds a match it substitutes the text in the pattern with the replacement text.
===
#/

/#
/tabadd
======
Format: /tabadd {word}

Adds a word to the tab completion list.

   {word} The word to add to the tab completion list.
===
#/

/#
/tabdelete
=========
Format: /tabdelete {word}

Removes a word from the tab completion list.

   {word} The word to delete from the tab completion list.
===
#/

/#
/tablist
=======
Format: /tablist

Shows you all the words you have defined in the tab completion list.
===
#/

/#
/textin
======
Format: /textin {filename}

Sends the contents of a textfile to the mud.

   {filename} The name of the file to send.
===
#/

/#
/un...
=====
Format: /un[command] {reference number} 
Format: /un[command] {text pattern} 

Removes a command (and places it into the undo list, see /undo). You can either type the number of the command which you see when you list the commands or an exact text match of the trigger/name portion of the command.

   [command] can be: action, alias, baritem, event, gag, highlight, macro, substitute, or variable.
   {reference number} The number of the action to remove.
   {text pattern} The trigger text of the action to remove.

Also See:
/undo
/unchat
===
#/

/#
/unchat
======
Format: /unchat {reference number}
Format: /unchat {chat name}

UnChat disconnects a chat connection.

   {reference number} The number of the chat connection you want to hang up on.
   {chat name} The name of the chat connection you want to hang up on.
===
#/

/#
/undo
====
Format: /undo
Format: /undo {number}

   {number} - Number of the command in the list to undo.

Anytime a command (alias, action, macro, etc..) is delete it is place in the undo list. The undo list remembers the last 50 commands deleted. /Undo without a number will show you a list of the most recent deletions. To undelete an item type /undo with the number of the item you want to restore.
===
#/

/#
/updatebaritem
=============
Format: /updatebaritem {item number}
Format: /updatebaritem {item name}

Causes an item on the status bar to redraw itself.

   {item number} The number of the item you want to update.
   {item name} The name of the item you want to update.
===
#/

/#
/updatestatusbar
===============
Format: /updatestatusbar

Refreshes all of your bar items at the same time.
===
#/

/#
/variable
========
Format: /variable {variable name} {value} {group}

   {variable name} Name of the variable. The first character of the var's name must NOT be a numeral (eg: /var {1score} is an invalid variable name. /var {score1} is valid. /var {score222win} is also valid. Normal alpha-numeric characters should be used for var names, although with some effort you can try to use such characters as "_" (/var {Name_Is} {Joe} will work, but retrieving the info requires @Var() (see @Var()). --Oma
   {value} The contents of the var. eg: /var {MyVar} {5} ..MyVar's value is "5". --Oma
   {group} optional group name of the variable. --Oma

The variable command adds a variable to your variable list and assigns it a value. If the variable is already in the list the value is replaced with the new value.

/variable {Target} {orc} 
Adds a variable called Target to your list of variables and gives it a value of "orc". 

There are several variables that are defined by the client. The client will let you if you insist, but you should probably not define variables with these names. If you do your version of the variable will be found before the system variable. For a list of system variables see the User Guide.
===
#/

/#
/version
=======
Format: /version

Displays the version of the client you are using.
===
#/

/#
/volumebits
==========
Format: /volumebits {[8 or 16]}

MM calculates the volume values based on 16bit or 8bit values. I don't know how to tell how many bits a sound card supports for the volume control. Right now I'm assuming if it can play 16bit samples, it has 16bit volume.  If it makes a wrong assumption, you can set it with this command. You can test and see if MM guessed correctly by playing wave at a few dif volume levels and see if it actually makes a difference in the playback volume. Try 50, 75, and 100.
===
#/

/#
/volumedefault
=============
Format: /volumedefault {1-100}

This is the percentage of the max volume that sounds are played at if a volume value is not given in the /playmidi or /playwav calls.
===
#/

/#
/volumemax
=========
Format: /volumemax {1-100}

This sets the maximum volume the client will play sounds at. This number is a percentage of the volume for your sound card. All sound volumes are compared against this value.
===
#/

/#
/while
=====
Format: /while {condition} {commands}

While executes the command as long as the condition is true.

   {condition} A condition that evaluates to true or false. See help on if for information on the condition.
   {commands} The commands will be executed until the condition is false. 

Caution is advised when using the while command. It creates a loops that does not stop until the condition is evaluated as false. If you create a condition that never evaluates to false it will stay in an infinite loop. An example of an infinite loop is this: /while {1 = 1} {say doh!} This while will never stop executing and the program will appear locked up. The idea behind the while is to create a condition that uses variables. Somewhere in the commands portion you would set a variable causing the loop to fail.
===
#/

/#
/write
=====
Format: /write {filename}

Writes all your commands, aliases, actions etc... to a file.
===
#/

/#
/writegroup
==========
Format: /writegroup {filename} {group}

Writes all your commands, aliases, actions etc... belonging to a certain group to a command file.

   {filename} The name of the file to write your commands to.
===
#/

/#
/zap
===
Format: /zap

Kills your connection to the mud.
===
#/

/#
@Abs()
====
Format: @Abs(number)

Returns the absolute value of an number.
===
#/

/#
@Asc()
====
Format: @Asc(character)

Pass in a character, it returns the ASCII value. @Asc(A) = 65.
===
#/

/#
@CharColor()
==========
Format: @CharColor(character position)

CharColor is useful only in actions. It returns the color of the character in a specific position on the line that caused the trigger to fire.

   character position - The 0 based index of the character to check.
===
#/

/#
@ChatConnects()
=============
Format: @ChatConnects()

Returns the number of chat connections you have.
===
#/

/#
@ChatName()
=========
Format: @ChatName()
Format: @ChatName(index)

Without any argument it will return your chatname.

If you include an index number it will return the name of that person (use /chat to see list). eg: /showme @ChatName(1) would return the name of the first person in your chat list. --Oma
===
#/

/#
@Chr()
====
Format: @Chr(number)

Chr works like the basic command Chr$. It returns the ascii equivalent of the number.

   number - Must be between 0 and 255.

@Chr(65) would return a capital A. @Chr(3) is a heart, etc...
===
#/

/#
@CommandToList()
==============
Format: @CommandToList(List Name,Commands)
Format: @CommandToList(List Number,Commands)

CommandToList lets you send a specific command for each of the items in the list. For each item in the list as the command is processed the system variable $ListItem is filled in with the current item.

   List Name - Name of the list to use.
   List Number - Number of the list to use.
   Command - Commands to execute for each item in the list.

@CommandToList(Friends,tell $ListItem Hi) 
Assuming your list had the names Rand and Egwene in it the following text would be sent: "tell Rand Hi" and "tell Egwene Hi" 

@CommandToList(Stuff,$ListItem) 
The above would simply process each of the items in the list.

Oma's Tip: you can add multiple commands, but use bracers as needed to denote entries and put a forward slash before any semi-colon. eg: @CommandToList(MyList,/var MyVar {1}\;/var MyVar2 {500}\;/showme {$MyVar $MyVar2}\;shout Woo!!)
===
#/

/#
@ConCat()
======
Format: @ConCat(text1,text2)

ConCat returns the concatenation of two text strings.

   text1 - The text to be appended to.
   text2 - The text to append to text1. 

/var test @ConCat(This is, a test!) 
Would place the string "This is a test!" in a variable called test.
===
#/

/#
@Connected()
=========
Format: @Connected()

Returns a 1 if you have an active winsock connection. Returns a 0 if you don't.
===
#/

/#
@Day()
====
Format: @Day()

Returns the day number of the current date. Between 1 and 31.
===
#/

/#
@EventTime()
=========
Format: @EventTime(event name)

EventTime returns how many seconds are left in an event before it fires.
===
#/

/#
@Exists
======
Format: @Exists(var name)

Returns a 1 if the variable exists, otherwise a 0.

   var name - The name of the variable to look for.
===
#/

/#
@FileExists()
==========
Format: @FileExists(filename)

Returns a 1 if the file exists, otherwise a 0.

   filename - The path and filename of the file to look for.
===
#/

/#
@GetArray()
=========
Format: @GetArray(array name,row,column)

GetArray returns the value of a cell in an array.

   array name - The name of the array from which you want to get the cell value.
   row - The row number of the array. This number must be between 1 and the number of rows you defined for the array.
   column - The column number of the array. This number must be between 1 and the numer of columns you defined for the array. This third parameter is required, even when using a single dimensional array. However, when using a single dimensional array, it is ignored. 

@GetArray(Targets,1,0) 
If Targets is a single dimensional array the column parameter would be ignored but it required to be there. This would return the value of the first row of the array Targets. 

@GetArray(Grid,2,4) 
If Grid is a two dimensional array, this would return the value of the cell at row 2, column 4.
===
#/

/#
@GetCount()
=========
Format: @GetCount(List Name)
Format: @GetCount(List Number)

GetCount returns the number of items in a list.

   list name - The name of the list from which you want to get the number of items.
   list number - The number of the list from which you want to get the number of items.
===
#/

/#
@GetItem()
========
Format: @GetItem(List Name,Number)
Format: @GetItem(List Number,Number)

GetItem retrieves an item from a list by number.

   list name - The name of the list from which you want to get an item
   list number - The number of the list from which you want to get an item.
   number - The number of the item you want to get.

@GetItem(Friends,1) 
Assuming you had a list called friends, this would give you the first item in that list.
===
#/

/#
@GetKey()
=========
Format: @GetKey()

Returns the next key typed. If there is no character in the buffer it will wait until a key is pressed.
===
#/

/#
@Hour()
=====
Format: @Hour()

Returns the hour of the current time. Between 0 and 23.
===
#/

/#
@InList()
=======
Format: @InList(List Name,Text To Find)
Format: @InList(List Number,Text ToFind)

Returns: 1 if the text is in the list, otherwise 0

InList determines if a specific text string is in a user defined list. InList can be evaluated in an /if statement. While you can use the list number to specify a list to search I don't recommend it. If you added a new list it might change the number of the list are looking for.

   list name - The name of the list you want to check.
   list number - The number of the list you want to check.
   item text - The item you want to search for in the list. 

/if {@InList(Friends,Rand)} {say Rand is in the list.} {say Rand is not in the list.}
If the word "Rand" is in the list called "Friends" the text "say Rand is in the list." would be sent to the mud, else the other string would be. 

/if {@InList(Friends,Rand) = 0} {say Rand is not in the list.} 
Searches for the word "Rand" in the list "Friends" and if it is NOT found the text "say Rand is not in the list." is sent to the mud.
===
#/

/#
@IsEmpty()
========
Format: @IsEmpty(var name)

Returns a 1 if the variable is empty, otherwise a 0.

   var name - The name of the variable to check.
===
#/

/#
@IsNumber()
=========
Format: @IsNumber(text)

Returns 1 if the text passed in is all numbers. Otherwise it returns 0.
===
#/

/#
@KeyWaiting()
===========
Format: @KeyWaiting()

Returns 1 if there is a key waiting to be processed, otherwise 0.
===
#/

/#
@Left()
=====
Format: @Left(text,number of characters)

Left returns a number of characters from the left side of a string.

   text - The text you want to take the left hand portion of.
   number of characters - Number of characters you want. 

@Left(Arithon,3) 
Would return the string "Ari". The 3 leftmost characters.
===
#/

/#
@Len()
===
Format: @Len(text)

Len returns the number of characters in a string.

@Len(Arithon) 
Would return 7.
===
#/

/#
@Lower()
======
Format: @Lower(text)

Lower converts all the letters in the text to lower case.  This can be useful when comparing items in a list or with an /if.

   text - some string

Examples:
   /if {"@Lower($Name)" == "arithon"}

   @InList(Spells,@Lower($1))
===
#/

/#
@LTrim()
=====
Format: @LTrim(text)

LTrim removes any spaces from the left side of a string.
===
#/

/#
@Math()
=====
Format: @Math(expression)

Returns the result of a math expression. The works the same way as /math, only the value is not placed into a variable. See the help on math for more information.
===
#/

/#
@Mid()
====
Format: @Mid(text,start character,number of characters)

Mid returns a portion of a string. You tell mid what character you want to start at, and how many characters from that point on. Strings are zero based, so if you want the very first character in a string the start character would have to be zero.

   text - Text string from which you want to grab a portion.
   start character - The character index of the first character to get.
   number of characters - The number of characters to get. 

@Mid(Arithon,0,3) 
This will get you the same result as using a @Left(Arithon,3). The text "Ari" would be returned.

@Mid(Arithon,2,4) 
Would return the string "itho".
===
#/

/#
@Minute()
=======
Format: @Minute()

Returns the minutes of the current time. Between 0 and 59.
===
#/

/#
@Month()
======
Format: @Month()

Returns the month number of the current date. Between 1 and 12.
===
#/

/#
@Num...
=======
Format: @Num[command]()

Returns the number of commands.

   [command] = Actions, Alias, BarItems, Events, Gags, Highlights, Lists, Macros, TabList, Substitutes, and Variables

Ex:
say I have @NumActions() actions!
===
#/

/#
@PadLeft()
========
Format: @PadLeft(text,character,number)

Returns a string padded on the left with a specific character.

   text - Text to pad.
   character - Character to use for padding.
   number - number of pad characters to add.
===
#/

/#
@PadRight()
=========
Format: @PadRight(text,character,number)

Returns a string padded on the right with a specific character.

   text - Text to pad.
   character - Character to use for padding.
   number - number of pad characters to add.
===
#/

/#
@PreTrans()
========
Format: @PreTrans(stuff to do)

Many commands in Mud Master translate variables and evaluate procedure when the command is executed. An example of this is when you define a macro that contains a variable -- when you press the macro key the variable gets translated. Sometimes, however, you will want the macro to store the value of that variable instead of the variable name itself. PreTrans allows you to expand variables and evaluate procedures at the time the command is created.

/macro {f1} {say $Var}
When the F1 key is press the variable gets translated. 

/macro {f2} {say @PreTrans($Var)} 
In this case, using PreTrans, the variable gets expanded when the macro is created. If $Var="Bob" the macro created is essentialy: /macro {f2} {say Bob}
===
#/

/#
@Random()
=======
Format: @Random(Max Number)

Random returns a number between 1 and Max Number.

say @Random(100)
Would say a number between 1 and 100.

say @GetItem(Greetings,@Random(@GetCount(Greetings))) Rand! 
If you had a list that contained a bunch of different greetings the above would randomly select one to use.
===
#/

/#
@Right()
=====
Format: @Right(text,number of characters)

Right returns a number of characters from the right side of a string.

@Right(Arithon,3) 
Would return the string "hon". The 3 rightmost characters.
===
#/

/#
@RTrim()
=====
Format: @RTrim(text)

RTrim removes any spaces from the right side of a string.
===
#/

/#
@Second()
=======
Format: @Second()

Returns the seconds of the current time. Between 0 and 59.
===
#/

/#
@StripAnsi()
==========
Format: @StripAnsi(text)

Pass in some text and it returns the same text with all the ansi codes removed.
===
#/

/#
@StrStr()
======
Format: @StrStr(search in,search for)

StrStr searches for the occurrence of one string in another. It returns the 0 based index of where the string to search for starts in the other. If the search for string is not found -1 is returned.
===
#/

/#
@TextColor()
==========
Format: @TextColor(text)

This procedure is only useful in an action. It searches the line of text that caused the action to fire for the text passed in. It returns the color of the first character that matches.
===
#/

/#
@Upper()
======
Format: @Upper(text)

Upper converts all the letters in the text to upper case.  This can be useful when comparing items in a list or with an /if.

Examples:
   /if {"@Upper($Name)" == "ARITHON"}

   @InList(Spells,@Upper($1))
===
#/

/#
@Val()
====
Format: @Val(text)

Pass in some text and it returns the numerical value. This has limited value since MM treats string and numerical variables pretty much the same. What it can do is help to trim off numbers at the front of a string. It will pull as the value, from the start, all numerical characters.
===
#/

/#
@Var()
===
Format: @Var(text)

Var returns the value of a variable named by the parameter text. This procedure allows you to construct a variable name as a paramter then look up the value of that variable. This is probably best explained by example.

Let's say you have a user defined list. In this list you have a bunch of names. Each of these names represents a variable that you have defined. We have the names: Rand and Egwene in the list. And we also have variables that are called Rand and Egwene.

This list would look like this:

   # Items in list Names(2): 
   001: Egwene 
   002: Rand 

And we have two variables defined:

   # Defined Variables: 
   001: {Egwene} {100} 
   002: {Rand} {250} 

Now lets say we want to see the value of a variable using the list procedures. If we just use the normal list procedures we are only going to get the text names from the list. @Var provides a way to take that text name and look it up as if it were a variable.

   @GetItem(Names,1) would get use the first name in the list: "Egwene"

   @Var(@GetItem(Names,1)) would first get the text "Egwene" from the list then the text would be used by the @Var procedure to look up "Egwene" as if it were a variable name; which it is. @Var would then return the value of the variable; which is 100.
===
#/

/#
@Version()
========
Format: @Version()

Returns the version of Mud Master.
===
#/

/#
@Word()
====
Format: @Word(string,word number)

Word returns a specific word from a string. A handy use for this procedure is passing in multiple words to an alias -- the alias can then easily separate the different words.

@Word(This is a test,2)
This would return the word "is". 

/alias {test %0} {say @Word($0,2)}
Typing "test This is a test" would pull the second word out of the string passed to the alias and produce: "say is".
===
#/

/#
@WordColor()
==========
Format: @WordColor(word number)

This is only useful in an action. Pass in the number of the word whose color you want to check in the line that set off the action. It returns the color of the first character of that word.
===
#/

/#
@WordCount()
==========
Format: @WordCount(text)

Returns the number of words in the text passed in.
===
#/

/#
@Year()
=====
Format: @Year()

Returns the year of the current date.
===
#/

/#
_______________________
(seperator)
#/
/#
Info/Help Topics:
(header)
#/
/#
System Variables
================

$ForeColor 
Keeps track of the current text color. Could be used in an /if statement to validate a color of a trigger.

I believe that $ForeColor only captures the string's initial color code, if the line is multi-colored, then $ForeColor only returns the first color of the string. There are many procs that can help narrow down a search for particular colors within a given string of text. $ForeColor is handy though, in that you don't have to do any checks, MM's already captured the ForeColor when the incoming text string arrived, assuming all you need is the initial color that is. --Oma

$ListItem 
This is the variable to use when using list procedures. It holds the value of the current list item when cycling through the list. 

$LoopCount 
When using the /loop command this is the current value of the loop.

You can also define the LoopCount variable by adding a third perameter to the loop call: /loop {start,end,VarName}, eg: /loop {1,10,Loop1} ..would use $Loop1 for the loop's variable. --Oma 
===
#/

/#
Time Procedures
===============

@Time() - Returns the number of seconds elapsed since January 1, 1970. Time can be used to create your own online timers. If you put the result of @Time() in a variable, then later on get the value of time again, you can subtract them for the number of seconds elapsed. The value from @Time() is also used for all the functions below.

@TimeToDay(time value) - Returns the day of the month.

@TimeToDayOfWeek(time value) - Returns the day of the week. 0 = Sunday, 6 = Saturday.

@TimeToHour(time value) - Returns the hour of the day.

@TimeToMinute(time value) - Returns the minute of the hour.

@TimeToMonth(time value) - Returns the month of the year.

@TimeToSecond(time value) - Returns the seconds of the minute.

@TimeToYear(time value) - Returns the year.
===
#/

/#
@IP(), @IPP()
=========
Format: @IP(), @IPP()

@IP() returns your IP address. @IPP() returns both your IP address and the port MM is listening for chat connections on.
===
#/
