ABS  |  ABSOLUTE
{abs:expr}

ADD  |  ADDITION
{add:expr1,expr2}
{add:expr1,expr2,expr3...}

AND  |  &&
{and:expr1,expr2...}

ARG  |  &ARG
{&arg}

ATTR | ATTRIBUTE
{attr:attr1,attr2...,text}

AWAKE
{awake:player}

CENTER
{center:string}
{center:string,fieldwidth}
{center:string,fieldwidth,padstring}

COMMAS
{commas:list}
{commas:list,lastsep}
{commas:list,lastsep,var,expr}

Takes a list and returns a plain english comma delimited string with the items in it. For example, {commas:{mklist:Tom,Dick,Harry}} will return "Tom, Dick and Harry". If you specify the lastsep argument, you can replace the "and" with something else, such as "or" to get a result like "a, b or c". Note: You need to be careful to include spaces around the "or" or else you might get a result like "a, borc".

Example:

  {commas:{mklist:a,b,c}, or }

CMD  |  &CMD
{&cmd}

CONCAT
{concat:listname}
{concat:listname,obj}

CONTAINS
{contains:obj1}
{contains:obj1,obj2}

CONTENTS
{contents:obj}
{contents:obj,type}

Returns a list of the contents of the given object. If a second argument is passed to it, it restricts the listing to only those objects that are of the given type. Either the object must be nearby the trigger object, or else the owner of the trigger object must control the object. Otherwise this will error out with a Permission Denied error. The valid object type values are Room, Thing, Exit, Player, Program, and Bad. Hint: If you need to get a list of two types of objects from the room, just concatenate the lists from two calls to this function, with each object type you want. For example:

  {mklist:{contents:here,player},{contents:here,thing}}       - or -
  {contents:here,player}{nl}{contents:here,thing}

CONTROLS
{controls:obj}
{controls:obj,player}

CONVSECS
{convsecs}

CONVTIME
{convtime:string}

COUNT
{count:list}
{count:list,sep}

CREATED
{created:obj}

DATE
{date}
{date:timezone}

DBEQ  |  DBEQUALS
{dbeq:obj1,obj2}

DEBUG
{debug:expr}

DEBUGIF
{debugif:condition,statement}

DEC  |  DECREMENT
{dec:var}
{dec:var,val}

DELAY
{delay:secs,expr}

DELPROP
{delprop:propname}
{delprop:propname,object}

DICE
{dice:X}
{dice:X,Y}
{dice:X,Y,Z}

DIST  |  DISTANCE
{dist:x,y} Returns distance from 0,0 that x,y is.
{dist:x,y,z} Returns distance from 0,0,0 that x,y,z is.
{dist:x,y,x2,y2} Returns distance between x,y and x2,y2.
{dist:x,y,z,x2,y2,z2} Returns distance between x,y,z and x2,y2,z2.

DIV  |  DIVIDE
{div:expr1,expr}
{div:expr1,expr2,expr3...}

EQ  |  EQUALS  |  ==
{eq:expr1,expr2}

EVAL
{eval:string}

EXEC
{exec:propname}
{exec:propname,obj}

EXEC!
{exec!:propname}
{exec!:propname,obj}

EXITS
{exits:obj}

FILTER
{filter:var,list,expr}
{filter:var,list,exp,sep}
{filter:var,lst,exp,sep,s2}

FLAGS
{flags:obj}

FOLD
{fold:var1,var2,list,expr}
{fold:var1,var2,lst,expr,sep}

FOR
{for:varname,start,end,increment,command}

FORCE
{force:object,command}

FOREACH
{foreach:var,list,expr}
{foreach:var,list,expr,sep}

FOX
{fox}

FTIME
{ftime:format}
{ftime:format,tz}
{ftime:format,tz,secs}

FULLNAME
{fullname:obj}

GE  |  >=
{ge:expr1,expr2}

GT  |  GREATERTHAN  |  >
{gt:expr1,expr2}

HOLDS
{holds:obj1}
{holds:obj1,obj2}

HOW  |  &HOW
{&how}

IDLE
{idle:player}

IF
{if:check,true}
{if:check,true,false}

This is a simple conditional command. It evaluates the check argument and if it is true, then it evaluates the true argument and returns its result. If check does not evaluate as true, then it will evaluate the false argument, if there is one, and returns its result. If there is no false argument, and check evaluated false, then it returns a null string. Example:

    Your computer is {if:{eq:2,3},broken!,All right.}

INC  |  INCREMENT
{inc:var}
{inc:var,val}

INDEX
{index:propname}
{index:propname,obj}

INDEX!
{index!:propname}
{index!:propname,obj}

INSTR
{instr:str1,str2}

ISDBREF
{isdbref:dbref}

ISNUM
{isnum:number}

ISTYPE
{istype:obj,typ}

KILL
{kill:0}
{kill:processID}

LASTUSED
{lastused:obj}

LCOMMON
{lcommon:list1,list2}

LE  |  <=
{le:expr1,expr2}

LEFT
{left:string}
{left:string,fieldwidth}
{left:string,fieldwidth,padstring}

LEXEC
{lexec:listname}
{lexec:listname,obj}

LINKS
{links:obj}

LIST
{list:listname}
{list:listname,obj}

LISTPROPS
{listprops:propdir}
{listprops:propdir,object}
{listprops:propdir,object,pattern}

LIT  |  LITERAL
{lit:string}

LMEMBER
{lmember:list,item}
{lmember:list,item,delimiter}

LOC  |  LOCATION
{loc:obj}

LOCKED
{locked:player,obj}

LRAND
{lrand:list}
{lrand:list,seperator}

LUNION
{lunion:list1,list2}

LUNIQUE
{lunique:list}

LREMOVE
{lremove:list1,list2}

LSORT
{lsort:list}
{lsort:list,var1,var2,expr}

Returns the sorted contents of list. If 4 arguments are given, then it evaluates expr with a pair of values, in var1 and var2. If expr returns true, then it will swap the positions of the two values in the list. It runs this comparison on every pair of items in the list, so it will be evaluated N*N times, where N is the number of items in the list. This method can also be used to randomize a list. Example:

    {lsort:{&list},v1,v2,{gt:{dice:100},50}}

LT  |  LESSTHAN  |  <
{lt:expr1,expr2}

LTIMESTR
{ltimestr:secs}

MAX  |  MAXIMUM
{max:expr1,expr2}

MKLIST
{mklist:value...}

Returns a list with all the given values as list items, seperated by carriage returns. (\r's) Example: {mklist:Tom,Dick,Harry} returns "Tom\rDick\rHarry". Note: A maximum of nine items can be passed to the {mklist} function. If you need more, you can chain {mklist}s together. Example:

    {mklist:{mklist:a,b,c,d,e,f,g,h,i},j,k,l,m,n,o,p}

MIDSTR
{midstr:str,pos}
{midstr:str,pos1,pos2}

MIN  |  MINIMUM
{min:expr1,expr2}

MODIFIED
{modified:obj}

MOD  |  MODULO
{mod:expr1,expr2}

MONEY
{money:obj}

MUCKNAME
{muckname}

MUF
{muf:prog,arg}

MULT  |  MULTIPLY
{mult:expr1,expr2}
{mult:expr1,expr2,expr3...}

NAME
{name:obj}

NE  |  NOTEQUALS  |  !=  |  <>
{ne:expr1,expr2}

NEARBY
{nearby:obj}
{nearby:obj,obj2}

NL  |  \r
{nl} or \r

Returns a carriage return character. This can be used to seperate items in a list, or can split the string at that point, starting a new line. Example: the string:

    This is\ran example{nl}of using newlines.

would print out like:

This is
an example
of using newlines.

NOT  |  !
{not:expr}

NULL
{null:expr...}

ONLINE
{online}

ONTIME
{ontime:player}

OR
{or:expr1,expr2...}

OTELL
{otell:string}
{otell:string,room}
{otell:string,room,player}

OWNER
{owner:obj}

PARSE
{parse:var,list,expr}
{parse:var,list,expr,sep}
{parse:var,list,expr,sep,s2}

PRONOUNS
{pronouns:string}
{pronouns:string,object}

PROP
{prop:propname}
{prop:propname,obj}

PROP!
{prop!:propname}
{prop!:propname,obj}

PROPDIR
{PROPDIR:propname,obj}

RAND
{rand:listname}
{rand:listname,obj}

REF
{ref:obj}

RIGHT
{right:string}
{right:string,fieldwidth}
{right:string,fieldwidth,padstring}

Takes a string and pads it to fit the given fieldwidth, with the string right justified. If no padstring is given, it assumes that it will pad the string with spaces. If no fieldwidth is given, it assumes that the field width is 78 characters. Example:

    {right:Hello,10,_.}

would return the string

    "_._._Hello"

SECS
{secs}

SELECT
{select:value,listname}
{select:value,listname,object}

Returns the value of a single list item from a sparse property list. The item chosen is the one who's line number is the largest one that is less than or equal to the given value. If the list is missing any items, then {select} will return the item in the list with the highest line number that is less than or equal to the given value. For example, if the list has the following entries:

_junk#/1:one
_junk#/5:two
_junk#/16:three
_junk#/20:four

SET
{set:var,value}

SIGN
{sign:expr}

SMATCH
{smatch:str,pattern}

Matches str against the wildcard pattern. If there is a match, this returns true, or "1". If it doesn't match, this returns a value of "0", or false. In wildcard patterns, the following characters have the following meanings:

STIMESTR
{stimestr:secs}

STORE
{store:val,prop}
{store:val,prop,obj}

STRIP
{strip:string}

SUBLIST
{sublist:list,pos1}
{sublist:list,pos1,pos2}
{sublist:list,pos1,pos2,sep}

SUBST
{subst:str,old,new}

SUBT  |  SUBTRACTION
{subt:expr1,expr2}
{subt:expr1,expr2,expr3...}

TELL
{tell:string}
{tell:string,player}

TESTLOCK
{testlock:obj,prop}
{testlock:obj,prop,who}
{testlock:obj,prop,who,def}

TIME
{time}
{time:timezone}

TIMESTR
{timestr:secs}

TIMESUB
{timesub:period,offset,listname}
{timesub:period,offset,listname,object}

This is sort of like {list}, except that it will only return one line of the given named property list. The line it chooses depends on the time. The period is the length of time, in seconds, that it takes for {timesub} to cycle through the entire list. The offset is the number of seconds to offset into the time period, if you actually need to synchronize the {timesub} with something. The offset usually is just left at zero. If the object argument is not passed, it looks for the list on the trigger. What this all means, is that if you have, for example, a period of 3600 (one hour), an offset of zero, and a property list that has six items in it, then {timesub} will return the first line of the property list during the first ten minutes of the hour, the second line during the next ten minutes, and so on, until it returns the last line during the last ten minutes of the hour. Then it returns the first line for the beginning of the next hour. Here's an example:

    {timesub:86400,0,_sunmoon}

TOLOWER
{tolower:string}

TOUPPER
{toupper:string}

TYPE
{type:obj}

TZOFFSET
{tzoffset}

USECOUNT
{usecount:obj}

V  |  VARIABLE  |  &
{v:var}
{&var}

VERSION
{version}

WHILE
{while:check,expr}

WITH
{with:var,val,expr..}

This defines a new variable with the given name, and sets its value to the given val. Up to 7 expr's are allowed, but the only value returned to {with}'s caller, is the value returned by the evaluation of the last expr. If there is already a variable of the same name, then this command will override that variable, for the duration of the {with:} command. The new variable is only valid to use within the confines of the {with:} command, and it will go away after the command completes. This provides scoped variables quite effectively. Note: There can be no more than 32 variables defined at any one time, total. This includes variables that are defined within macros, or properties or lists that are executed with {exec:} or {lexec:}. Here's an example to illustrate the scope of variables inside of {with:} commands:

  {prop:_mydesc}                        <- {&people} not defined
  {with:people,{contents:here,players}, <- Defining. Not available yet
    {if:{count:{&people}},              <- It's usable now
      The players awake here are
      {lit: }                           <- just puts in a space
      {commas:{&people},{lit: and },
        who,{name:{&who}}               <- uses {&who} as temp var
      }                                 <- {&who} no longer defined
    }
  }                                     <- {&people} no longer defined

XOR  |  EXCLUSIVEOR
{xor:expr1,expr2}