
help available on the following:

action                  alias                   all
antisubstitute          bell                    boss
brokentelnet		call			char                    
chat			chatall			clearprompt		
chatname		chatpriv		chattransfer
chat.conf		cinfo			cr
echo			emote			emoteall
end                     filecancel		filestat
fixedmath		forall			function		
gag                     getwalkdirection	getvarvalue
getlistlenght		getitemnr		help			
highlight               history                 if			
ifstrequal		ifexist			ifmatch			
ignore                  info                    killall			
log                     loop                    map			
mark                    math                    message			
nop			path                    pathdir			
ping			presub			prepad			
postpad			purist			random
read                    redraw			request
result			retab                   return			
revstring		removestring		savepath		
sendfile		setprompt		session                 
showme			sleep			snoop			
speedwalk               split                   substitute		
suspend                 system                  tabadd			
tabdelete               tablist                 tabsave			
textin			tick                    tickoff                 
tickon			tickset			ticksize                
timetry			tolower			togglesubs		
toupper                 tries			unaction                
unalias			unantisubstitute        unchat			
unfunction		ungag			unhighlight		
unpath			unpurist		unsplit                 
unsubstitute		unvariable              variable                
verbatim		version                 walk			
walkback		walkinfo		walkon			
walkoff			walkreset		walkset			
wildcard		wizlist			write                   
writesession            zap			zombion			
zombioff		helpversion


~ALIAS

format:     #alias [{word}] [{command(s)}]
            #alias [word] [command]

the [] signify optional arguments.

Define a word that actually means a longer string.  Useful for commands 
repeated often, or commands that are very lengthy.  You can have multiple
commands aliased to a single word, if you enclose the alias in {}.

If the command(s) include variables %0-9, these are substituted as part
of the parsing.  %0 is set to all text after the word was input, %1 is set
to the first word following the aliased word, and %2 is the second, and so on.

If the #alias command is typed without any arguments, all aliases defined will
be listed.

If the #alias command is typed with only 1 argument, occurrences matching the
input string are shown.  The * character is valid in this word to act as a
'wildcard'.  See help wildcard.

examples:
#alias gb get bread bag
typing gb at the prompt would be sent as 'get bread bag'.
#alias ws {wake;stand}
since ws aliases a multiple command, you must use the braces.
#alias heal cast 'heal' %1
typing 'heal valgar' at the prompt would be sent as 'cast 'heal' valgar' since
it will put the word valgar into %1
#alias
list all aliases
#alias he*
list all aliases that start with the letters 'he'
 
~ACTION

format:     #action [{string}] [{command(s)}] [{priority}]

The [] signify optional arguments.

Have the client search for a certain string of text from the mud, if the 
client receives that string, it will execute the command(s).  Variables
%0-9 are substituted from the input string, and can be used in the command(s)
side of the command. Previously, all actions were stored alphabetically in the
list, which meant that some of the important actions could exist at the end
of the list (which could result in slow reaction times for those actions).
Priorities have been added to actions now.  The third parameter of the command
will tell how important tintin should reguard this action (0 most important, 
9 least important).  If no priority is given, a default value of 5 is assigned.

if the string to be searched for starts with a ^, only the beginning of the 
line will be searched.

If #action is type with no arguments, all actions defined are listed.

If #action is typed with only one argument, actions defined that match that
argument are displayed.  The * character is valid in this case to use
as a 'wildcard'.  See help wildcard.

examples:
#action {Grimmy has arrived} {smile grimmy} {2}
If Grimmy enters the room, you will automatically smile at her.  The priority
setting of two, means that it should be stored close to the top of the list.
(all actions with 1 and 0 set for priorities will be checked before this one).
 
#action {^TICKCOUNTER: 5 seconds} {sleep} {0}
Since this string is 'anchored', it will only be triggered if it starts at
the beginning of a line.  If your mud has a tickcounter set up like this, 
this action will make you sleep at 5 seconds to tick.

#action 
list all actions

#action *tell*
list all actions with the word 'tell' in them.

~ALL

format:      #all {string}
             #all string

Send a command to all active sessions.

example:
#all {shout I'm multicharing!}

~ANTISUBSTITUTE

format:      #antisubstitute {string}
             #antisubstitute string

Will cause any line that contains the string specified to not be checked for
substitutes and gags.  The ^ char starting a string will tell the client to
only antisubstitute lines that START with the string specified.

examples:
#antisub {^You}
any line starting with 'You' will not be checked for subs.
#antisub {^You%0hit.}
lines that start with 'You', and also contain 'hit.' will not be subbed.
#antisub {annihilate}
any line that contains the word 'annihilate' will not be subbed.

~BELL

format:       #bell

sends a beep to your terminal.

example:
#action {tells you} {#bell}
will chime any time anyone tells you anything.

~BOSS

format:       #boss

puts some fake text on your screen so nobody knows you're mudding.

~CHAR

format:       #char character

lets you redefine your tintin_character, the character that starts all commands.

example:
#char /
all commands must then start with a /, instead of a #.  

The default tintin char can be set in tintin.h, and if you load a coms file, the
first character it sees is set to your tintin char.

~CR

format:	      #cr

Sends a carriage return to the session.  Useful for aliases that nees carriage
returns.

~ECHO

format:       #echo

Echo is used to see what actions are being triggered.  #echo toggles this
feature on and off.

~END

format:       #end

terminate tintin++ and return to unix.  On most systems, ctrl-C has the same 
effect.

~HELP

format:       #help [command]

get a listing of commands, or get help and a specific command.

~HIGHLIGHT

format:       #highlight [{type}] [{string}]
              #highlight [type] [{string}]

The [] signify optional arguments.

The higlight command is used to allow you to highlight strings of text from
the mud.  The possible types are bold, reverse, faint, italic, blink, or
a number between 1 and 8.  The numbers correspond to colors 1 through 8
of your color pallette.

New to v1.5, you can now use the color names as well as the old convention of
#'s for colors.  Valid color names include:

red, blue, cyan, green, yellow, magenta, white, grey, black, brown, charcoal,
light red, light blue, light cyan, light magenta, light green, b red, b blue, 
b cyan, b green, b yellow, b magenta, b white, b grey, b black, b brown, 
b charcoal, b light red, b light blue, b light cyan, b light magenta, 
b light green, bold, faint, blink, italic, reverse

The %0-9 variables can be used as 'wildcards' that will match with any text.
They are useful for highlighting a complete line.
You may start the string to highlight with a ^ to only highlight text
if it begins the line.

Note: This command is only compatible with ANSI/VT100 terminals or emulators.

examples:
#high {reverse} {Valgar}
print every occurrence of 'Valgar' in reverse video
#high {6} {%0tells you%1}
print every complete line that contains 'tells you' in color 6
#high bold {^You}
boldface any 'You' that starts a line
#high {red, blink} {Grimne} 
each time the word Grimne appeared, it's be shown in a blinking red color.

~HISTORY

format:        #history

The history command will display a listing of the most recent keyboard
input.

~IF

format:        #if {conditional} {command(s)}

The if command is one of the most powerful commands added since TINTINv3.
It works similar to an if statement in other languages, and is loosely based
on the way C handles its conditional statements.  When an if command
is encountered, the conditional statement is evaluated, and if TRUE
(any non-zero result) the command(s) are executed.  The if statement is
only evaluated if it is read, so you must nest the if statement inside 
another statement (most likely an action command).  The conditional is 
evaluated exactly the same as in the math command, only instead of storing
the result, the result is used to determine whether to execute the
command(s).  '#help math' for more information.

*!* Warning *!*:  #if can only compare numerical values at this time.  It can't 
be used to compare a set of strings (as of yet at least).

examples:
#action {%0 gives you %1 gold coins} {#if {%%1>5000} {thank %%0}}
if someone gives you more than 5000 coins, thank them.
the %%1 and %%0 belong to the action, and not to the if, and that is why
the double % are needed.
#action {^<hp:%0 } {#if {%%0<100} {flee}}
If your status prompt is of the form <hp:100 ma:50 mo:100>, this action
will get your hit points, compare them to 100, if less than 100, flee

~IGNORE

format:        #ignore 

Toggle actions on and off. If off, no actions will be checked for.

~INFO

format:		#info

Displays the number of actions, aliases, variables, substitues, 
antisubstitutes, and highlights for the current session.  If no session
is active, then the statistics on the defaults are given.

~KILLALL

format:		#killall

Killall deletes all aliases, actions, subs, antisubs, highlights, variables
in one fell swoop.  Useful now, so you don't have to exit tintin++ to 
load up a new coms file.

~LOG

format:        #log {filename}

Log session to a file.

~LOOP

format:        #loop {start,finish} {command(s)}

Like a for-next loop, will loop from start to finish incrementing or
decrementing by 1 each time through.  The value of the loop variable is 
places in %0, and can be used in the command(s).  If start>finish, it will 
loop backwards.

examples:
#loop {1,3} {get all %0.corpse} 
equivalent to the following:
  get all 1.corpse;get all 2.corpse;get all 3.corpse
#loop {3,1} {drop %0.key}
equivalent to
  drop 3.key;drop 2.key;drop 1.key

~MAP

format:        #map {direction}

Will add a direction to the end of the current path.  Useful for mapping
while following someone.

example:

#action {$leader leaves %0.} {#map {%%0}}
if the person stored in $leader leaves the room, the direction is added
to the end of the path.

~MARK

format:        #mark

Clear the path list and start the new path at your current location.

~MATH

format:        #math {variable} {expression}

Performs math functions and stored the result in a variable.  The math 
follows a C-like precedence, as follows, with the top of the list having 
the highest priority.

Operators                    Function
------------------------------------------------
!                            logical not
*                            integer multiply
/                            integer divide
+                            integer addition
-                            integer subtraction
>                            greater than (result is non-zero or zero)
>=                           greater than or equal (result is non-zero or zero) 
<                            less than (result is non-zero or zero)
<=                           less than or equal (result is non-zero or zero)
= or ==                      equals (result is non-zero or zero)
!=                           not equal (result is non-zero or zero)
& or &&                      logical and (result is non-zero or zero)
| or ||                      logical or (result is non-zero or zero)

True is any non-zero number, and False is zero.  In the expression, you may
use T and F as true and false.  Parentheses () have highest precedence, 
so inside the parentheses is always evaluated first.

examples:
#math {heals} {$mana/40}
Assuming there is a variable $mana, divide its value by 40 and store the 
result in $heals.
#action {^You receive %0 experience} {updatexp %0}
#alias updatexp {#math {xpneed} {$xpneed-%%0}
Let's say you have a variable which stores xp needed for your next 
level.  The above will modify that variable after every kill, showing
the amount still needed.

~MESSAGE

format:        #message {type}

This will toggle off and on the messages dealing with a certain type of
command.  The possible message types are alias, action, antisub, sub
variable, and highlight.  This is very helpful if you are using 
#math and #if, and setting a lot of variables, so you don't keep getting
the Variable Set messages.

example:
#message {variable}
toggles whether messages dealing with variables will be shown.

~NOP

format:        #nop [string]

A null operation, is ignored by the client.  It is useful for commenting
in your coms file, any text after the nop and before a semicolon or 
end of line is ignored.

example:
#nop This is the start of my autoactions

~PATH

format:        #path

Show your current path.

~PATHDIR

format:	       #pathdir {odd_dir} {what speedwalk should interpret it as}

New for v1.5, this command will allow those player who play on muds that
have diag./odd directions to use speedwalk. 

example:
#pathdir {nw} {nw} 
each time {nw} is excountered in the speedwalk, tintin++ will send a {nw} to 
the mud.

~PRESUB

format:        #presub

Toggle whether actions are processed before substitutes, or after.  With
presub on, actions are performed on the substituted buffer, and if 
you are gagging heavily, it will increase the speed of execution.  
There are also many times you don't want to check for actions on 
lines you have gagged, and this will allow that.

~REDRAW

format:        #redraw

If redraw is on, and you're not in split mode, the input 
line will be redrawn when any text arrives, or tintin++ prints any
messages.  This helps you avoid your input being spread out and 
unreadable when there is heavy text flow from the mud.  In split mode, 
this variable is ignored.

~RETAB

format:		#retab

New for v1.5.  #retab allows you to re-load the tab completion file.

~RETURN

format:        #return

Pop the last move off the top of the path, and move the opposite direction.

~READ

format:        #read {filename}
            or #read filename

Reads a coms file into memory.  The coms file is merged in with the
currently loaded commands.  Duplicate commands are overwritten.

~SAVEPATH

format:        #savepath {alias name}

Save the current path to an alias, which can then be saved to a coms file.
The alias name provided will be the new name of the alias to represent
that path.  Useful for after mapping to be able to get back to the place 
again.

~SHOWME

format:        #showme {string}

Display the string to the terminal, do not send to the mud.  Useful for
status, warnings, etc.  

example:
#action {%0 ultraslays you} {#showme {###### argh! we were ultraslayed ######}}

~SNOOP

format:        #snoop {session name}

If there are multiple sessions active, this command allows you to see what
is going on the the sessions that are not currently active.  The lines
of text from other sessions will be prefixed by 'session name%'.

~SPEEDWALK

format:        #speedwalk

Toggle speedwalking on and off.  Speedwalking allows you to type multiple
directions not seperated by semicolons, and now it lets you prefix a 
direction with a number, to signify how many times to go that direction.

example:
without speedwalk:
s;s;w;w;w;w;w;s;s;s;w;w;w;n;n;w
with speedwalk:
2s5w3s3w2nw

~SPLIT

format:        #split {line #}
               #split line #

New for 1.2, with a vt100 or ANSI emulator, this will allow you to set up
a split screen.  The keyboard input will be displayed in the bottom window, 
while mud text is displayed in the upper window.  This requires a fairly
decent emulator, but works on most I have tested.  The screen will be split
at the line indicated by line #, and should be around 3 lines above the 
bottom of the screen.  When the enter key is pressed, the text will
be sent to the mud, and also be echoed to the upper window.

If a line # isn't specified, the screen is split at line 21.

example:
#split 35
split the screen at line 35.

~SUBSTITUTE

format:        #substitute [{text}] [{new text}]

The [] signify optional arguments.

Allows you to replace original text from the mud with different text, or 
delete it altogether.  This is helpful for if you have a slow modem, or 
there is a lot of text sent during battles, and the like.  the %0-9
variables can be used to capture text and use it as part of the new output, 
and the ^ char is valid to only check the beginning of the line for the 
text specified.

If a . is the only character in the new text argument, if the line is
matched, it will be deleted.

If only one argument is given, all subs that match the string are displayed.
The * char is valid in this instance.  See help wildcard.

If no argument is given, all subs are displayed.

examples:
#sub {leaves} {.} 
gag any line that has the word 'leaves' in it.
#sub {^Zoe%0} {ZOE%0}
any line that starts with the name Zoe will be replaced by a line that
starts with 'ZOE'
#sub {%0massacres%1} {%0MASSACRES%1}
replace all occurrences of 'massacres' with 'MASSACRES'

~GAG

format:        #gag {string}

Just like substitute, but the . is added for you.  Removes any line that 
contains the string.

~SYSTEM

format:        #system {command}

Executes the command specified as a shell command.  The name of the system
command can be changed in tintin.h for your security.  

~TABADD

format:	       #tabadd {word}

Adds a word to the end of the tab completion list.

~TABDELETE

format:	       #tabdelete {word}

Deletes a word from the tab completion list.

~TABLIST

format:	       #tablist

Displays all words in the tab completion list.

~TEXTIN

format:		#textin {filename}

Textin now allows the user to read in a file, and send its contents directly 
to the mud.  Useful for doing online creation, or message writting.

~TICK

format:        #tick

Show seconds until next tick.

~TICKOFF

format:        #tickoff

Turn off the tintin++ built in tick counter.

~TICKSET

format:        #tickset

Turn on the tintin++ tickcounter, and set time until next tick equal 
to tick size.

~TICKSIZE

format:        #ticksize number

Set a new time, in seconds,  between ticks for the tintin++ tickcounter.

~TOLOWER

format:        #tolower var text

Just like the #variable command, only it converts the text
to lowercase before assigning it to the variable.

~TOGGLESUBS

format:        #togglesubs

Toggle whether substitutes should be ignored.  If subs are ignored, 
text will not be checked for subs, but highlights will still be 
checked for.

~TOUPPER

format:        #toupper var text

Just like the #variable command, only it converts the text
to uppercase before assigning it to the variable.

~UNACTION

format:        #unaction {string}
               #unaction string

Remove action(s) from the action list which match {string}.  The
'*' character will act as a wildcard and will match any text.
See help wildcard.

examples:
#unaction {%0tells you%1}
remove the action that is triggered by '%0tells you%1'
#unaction *
remove all actions
#unaction {*massacre*}
remove all actions that contain the word 'massacre'

~UNALIAS

format:        #unalias {word}
               #unalias word

Remove alias(es) from the alias list which match {word}.  The
'*' character will act as a wildcard and will match any text.
See help wildcard.

examples:
#unalias {bbb}
remove the alias 'bbb'
#unalias *
remove all aliases
#unalias {*go*}
remove all aliases that contain the fragment 'go'

~UNANTISUBSTITUTE

format:        #unantisubstitute {string}
               #unantisubstitute string

Remove antisub(s) from the antisub list which match {string}.  The
'*' character will act as a wildcard and will match any text.
See help wildcard.

examples:
#unantisub {%0tells you%1}
remove the antisub for '%0tells you%1'
#unantisub *
remove all antisubs
#unantisub {^You*}
remove all antisubs that start with '^You'

~UNGAG

format:        #ungag {string}
               #ungag string

Exactly the same as #unsubstitute, '#help unsubstitute' for info.

~UNSUBSTITUTE

format:        #unsubstitute {string}
               #unsubstitute string

Remove substitute(s) from the substitute list which match {string}.  The
'*' character will act as a wildcard and will match any text.
See help wildcard.

examples:
#unsub {%0tells you%1}
remove the sub for '%0tells you%1'
#unsub *
remove all subs
#unsub {^You*}
remove all subs that start with '^You'

~UNHIGHLIGHT

format:        #unhighlight {string}
               #unhighlight string

Remove highlight(s) from the highlight list which match {string}.  The
'*' character will act as a wildcard and will match any text.
See help wildcard.

examples:
#unhigh {%0tells you%1}
remove the highlight for '%0tells you%1'
#unhigh *
remove all highlights
#unhigh {^You*}
remove all highlights that start with '^You'

~UNPATH

format:        #unpath

Remove the most recent move from the current path.

~UNSPLIT

format:        #unsplit

Exit split mode, and set the screen back to its default terminal settings.

~UNVARIABLE

format:        #unvariable {variable name}
               #unalias variable name

Remove variable(s) from the variable list which match {variable name}.  The
'*' character will act as a wildcard and will match any text.
See help wildcard.

examples:
#unvar {hp}
remove the variable $hp
#unvar *
remove all variables
#unvariable {xx*}
remove all variables that start with 'xx'

~VARIABLE

format:        #variable {<variable_name>} {<text to fill variable>}

Since these are completely new to tintin, and act differently
than anything else, I feel should spend some time on them.
These variables differ from the %0-9 in the fact that you could
specify a full word as a variable name, and they stay in memory for
the full session, unless they are changed, and they can be saved in
the coms file, and can be set to different values if you have 2 or
more sessions running at the same time.  One of the best uses for
variables I think is for spellcasters.

Currently, you would set up a bunch of aliases like the following.

#alias {flame} {cast 'flame strike' %0}
#alias {flash} {cast 'call lightning' %0}
#alias {harm} {cast 'harm' %0}

With the new variables you can do the following:

#alias {targ} {#var target %0}
#alias {flamet} {flame $target}
#alias {flasht} {flash $target} 
#alias {harmt} {harm $target}

these aliases will be  defined just as they are written, the variables
are not substituted  for until the  alias is found  in your input  and
executed.

so, if before a battle, you do a:
targ donjonkeeper
then $target is set to donjonkeeper, and any alias you set up with
$target in it will substitute donjonkeeper for every instance of
$target.  Let's say your leader has the following alias set up.

#alias {setttarg} {#var {target} {%0};gt target=%0}

if he did a settarg lich, it would set his $target to lich, and
would send a:

<name> tells your group 'target=lich'

you could then set an action like so.

#action {^%0 tells your group 'target=%1'} {targ %1}

then when your leader executed his alias, it would also set your
variable to the target.

Another use for variables would be to set a variable $buffer to
whoever the current buffer is.  This would be useful in fights
where the mob switches, or where many rescues are needed.  You
could set up healing aliases with $buffer in them, and set the
$buffer variable in an action that is triggered by each switch,
and each rescue, or just rescues, or whatever.  Then in a
confusing battle, you will have a better shot at healing the
right person.

************   Variables for now, have to be alpha-only
*** NOTE ***   You cannot use variable names like:
************   text1, text2.  Support for this will be in v2.0

~VERBATIM

format:        #verbatim

New for 1.2

Toggle verbatim mode on and off.  When in verbatim mode, text will not be
parsed, and will be sent 'as is' to the mud.  Tab completion and history
scrolling are still available in verbatim mode.  It is helpful for writing
messages, doing online creation, and the like.

~VERSION

format:        #version

Show the version number of tintin++ that you are currently running.

~WIZLIST

format:        #wizlist

Lists the names of people who helped with with mudding, and with the client.
If you feel your name should be here, let me know, so many people have
contributed, and it's hard to name everyone.

~WRITE

format:        #write {filename}
               #write filename

Writes all current actions, aliases, subs, antisubs, highlights, and
variables to a coms file, specified by filename.  

~WRITESESSION

format:        #writesession {filename}
               #writesession filename

Write all current actions, aliases, subs, antisubs, highlights, and
variables that are specific to your current session to a file.  This 
means actions that were not defined when there was no session active.

~ZAP

format:        #zap

Kill your current session.  If there is no current session, it will cause
the program to terminate.

~SUSPEND

format:        #suspend

Temporarily suspends tintin++ and returns you to your shell.  The
effect of this command is exactly as if you had typed control-z.
To return to tintin++, type "fg" at the shell prompt.

~WILDCARD

format:		#command {regexp}

You may use wildcards with certain commands such as #alias, #action,
#substitute, #unalias, etc.  In commands like #alias, wildcards are
only valid when you use exactly one argument.  Wildcards are always
valid for commands like #unalias.  The only wildcard currently
supported is *, which matches any string 0 or more characters long.
The wildcard meaning of * may be escaped using the backslash, \.

Examples:

#action {*miss*}
	shows all actions which contain the word miss in them
#unaction {*miss*}
	removes all actions which contain the word miss in them
#unaction {\*\*\* PRESS RETURN:}
	removes the action which triggers on the line *** PRESS RETURN:

Many thanks to Spencer Sun for letting me steal some code for this...
If anyone is interested in having full ls-style regexps, email me
and maybe it'll be included in 2.0.

~RANDOM

format:		#random {<var_name>} {num}

Random will choose a random # from 1 to num, and store that value
in <var_name>.  You can access <var_name> as you would any variable
(see #help variable for help on variables).
 
~SETPROMPT

format:		#setprompt {string}

SetPrompt is a feature for split window mode (see #help split), which
will take the status prompt from the mud, and display it on the status
line of the split window.  You would define <string> the same way you
would an action (see #help action).  

~CLEARPROMPT

format: 	#clearprompt

ClearPrompt will turn off the prompt display to the split window.

~IFEXIST

Command: ifexists - checks if a variable exists or not 

Syntax:  #ifexists {varname} {do this} else {do this instead}

Example: #ife {leader} {say My leader is $leader!} else {say I have no leader!}

~IFMATCH

Command: ifmatch - checks a string for a mask containing text and *'s 

Syntax:  #ifmatch {mask} {string} {do this} {do this instead}

Example: #ifm {*Iny*} {This is a test string: Iny!} {#shomwe Works fine!} else {#showme Call 911 - the procedure doesn't work!}

~IFSTREQUAL

Command: ifstrequal - string comparisment 

Syntax:  #ifstrequal {string1} {string2} {do this} else {do this instead}

Example: #alias {tell} {#ifs {$1} {$whoami} {#showme [Tell to self]: %0} else {Tell %0}}

~GETVARVALUE

Command: getvarvalue - get the contents of a variable 

Syntax:  #getvarvalue {dest var} {source var}

Example: #getv {numberofmobs} {mobThe Spirit Guard}

Info:    The variable name can contain any character; not just alpha chars!
         This function was made more or less redundant when I introduced the
         improved naming of variables by allowing brackets around the name.
         ( ${variablename} ). But it's kept for compability with earlier
         comfiles.

~REVSTRING

Command: revstring - reverses a string/stores it backwards 

Syntax:  #revstring {dest var} {string}

Example: #revs myname Happy Iny <-- stores 'ynI yppaH' in the variable 'myname'

~POSTPAD

Command: postpad - pads a variable with spaces AFTER given text until variable
                   is of desired length (truncates if too long) 

Syntax:  #postpad {dest var} {length} {text}

Example: #postpad mobname 15 A huge, ancient tree, walking on giant roots,
         #postpad myname 15 Iny


~PREPAD

Command: prepad - pads a variable with spaces BEFORE given text until variable
                   is of desired length (truncates if too long)

Syntax: #prepad {dest var} {length} {text}

Example: #prepad mobname 15 A huge, ancient tree, walking on giant roots,
        #prepad myname 15 Iny


~GETLISTLENGTH

Command: getlistlength - returns the length of a list 

Syntax:  #getlistlength {dest var} {list}

Example: #getl Length {$alignlist}   <--- returns 3 in the Length variable


~GETITEMNR

Command: getitemnr - retrieves specified element from a list (NEW)

Syntax:  #getitemnr {destination variable} {item number} {list}

Example: #geti {dothis} {2} {smile {say Hi!} flip bounce}  <--- sets dothis to 'say Hi!'

Example: #getl Length {$rndsocial};#ran itemnr {1,$Length};#geti temp {$itemnr}
{$rndsocial};{$temp}
         (will perform a random social from the 'rndsocial' list)


~FUNCTION

FUNCTIONS:
==========
Added a new list type which I decided to call functions. These are a mixture of
aliases and
variables. The following examples will have to do to explain how to use functions:

Example:
#function {rnd} {#random {temp} {%1,%2};#result {$temp};#unvar temp}
#showme A random number between 0 and 100: @rnd{0 100}

Functions are treated much like variables. Their value is
a command-line which is executed, and the functions are substituted
by the parameter last sent to the #result command

Example:
#function {lastfuncresult} {#nop}
#showme Last use of a function gave @lastfuncresult as result.

NB! Functions are NOT evaluated at all the same places as variables so before
you decide to write a long comfile using functions - check if it works first! :)I might finish my work on the functions later, right now I'm too lazy to though.
=== FUNCTIONS ARE FOR INSTANCE _NOT_ EVALUATED INSIDE AN IF STATEMENT - YET! ===

~UNFUNCTION

Command: unfunction - remove a function 

Syntax:  #unfunction {func name}

~RESULT

Command: result - write a string to the function buffer

Syntax:  #result {-result-}

Example: #func {ctof} {#math result %0*9/5+32;{#result $result degrees fahrenheit};#unvar result}
         #showme 30 degrees celsius equals @ctof{30}.

Example: #func {ftoc} {#math result (%0-32)*5/9;{#result $result degrees celsius};#unvar result}
         #showme 80 degrees fahrenheit equals @ftoc{80}.

~BROKENTELNET

Command: brokentelnet - for muds that do not like getting \n\r
	 The command will toggle it on or off.  If you get like a double
	 new line, this would indict this problem.

~FIXEDMATH

Command: fixedmath
	 This command will toggle on the fixed versus old (broken) math.
	 The old math function would give wrong answers at times.  It
	 is recommanded that fixedmath be turned on.

~TRIES
Command: tries <number>
	 This command will change the number of times tintin will try to
	 keep trying to connect to a mud before giving up.

~TIMETRY
Command: timetry <number>
	 This command will change the time (in seconds) between reconnection
	 attempts.

~TICKON
Command: tickon
	 Thic command will enable the ticker to start counting.

~SLEEP
Command: sleep <number of seconds>
	 This commands will wait the number of seconds before it will process
	 any more commands.  This is useful if you want to do something X
	 seconds later in time.
~FORALL
	HELPFILE NEEDS TO BE WRITTEN.  BUG THE DEVELOPERS!

~PURIST
	HELPFILE NEEDS TO BE WRITTEN.  BUG THE DEVELOPERS!

~REMOVESTRING
	HELPFILE NEEDS TO BE WRITTEN.  BUG THE DEVELOPERS!

~TABSAVE
	HELPFILE NEEDS TO BE WRITTEN.  BUG THE DEVELOPERS!

~UNPURIST
	HELPFILE NEEDS TO BE WRITTEN.  BUG THE DEVELOPERS!

~GETWALKDIRECTION
	Syntax : #getwalkdirection {<variable-name>} [ {<position>}]
             Retrieves one pathdir from specified position within the 
             walk-path.
             <variable-name> specifies the variable to store retrieved 
             pathdir.
             The optional argument <position> specifies the position from 
             which the pathdir is retrieved. If it is omitted, the default 
             position for retrieval is the current walk position.

~WALK
	Walk one step in the speedwalk.

WALKBACK
	Walk back one step in the speedwalk.

~WALKINFO
	Gives information on the current speedwalk that is being walked
	through.  

~WALKON
	Turn on the standstill flag.

~WALKOFF
	Turn off the standstill flag.

~WALKRESET
	Syntax : #walkreset[ {<num-skip>}]
	An optional argument <num-skip> is the number of pathdirs
        to be skipped from the beginning of the path alias.
        A negative number will be ignored.

~WALKSET
	Syntax : #walkset {<alias-name>}
	Starts using alias pointed by <alias-name> as a
        path to walk through. The alias pointed by
        <alias-name> must be created by #savepath command.

~ZOMBION
	Turn on Zombie mode.

~ZOMBIOFF
	Turn off Zombie mode.

~CALL

format #call <IP address> [port]

Calls the designated IP and port and attempts to negotiate a MudMaster style
chat session with the other party.  If the other party accepts the call you
will then have a chat session through which you can communicate regardless
of the state of the mud server our your connection to it.

SEE: chat, chatall, emote, emoteall, chatname, unchat

 ~CHAT

format:       #chat [name <text>]

With no argument this command will print a list of the current chat
connections you have and the ip address, port, and version number of each.
With a name (which can be abbreviated and is not case sensitve) and some text,
it sends a personal chat message to that chat connection.

~CHATALL

format:       #chatall <text>

Sends a message (text) to all of your chat connections.

~CHATNAME

format:       #chatname <name>

Changes the name you are known by in your chat connections.

~CHATPRIV

format        #chatpriv <name>

Toggles whether or not the chat connection referenced by (name) is a private
connection.  Private connections cannot be called by other people in your
chat connection list.

~CHATTRANSFER

format:       #chattransfer <name>

Toggles whether or not the chat connection referenced by (name) can send files
to you through the chat file transfer protocol.

~CHAT.CONF

This file list the default boot values for your chat server.  It has a
standard format of:

TAGG : value<tilde symbol>

Where TAGG is a four letter tag symbol and value is the value for that tag.

Tags:

NAME -- Your chat name.
PORT -- The port your chat server listens on.  If you are on a multiuser
        computer you may need to change this value from the default of 4050
ICTO -- Incoming Call Time Out, the time in seconds to wait on an incoming
        chat connection before giving up.
OGTO -- Outgoing Call Time Out, the time in seconds to wait on an outgoing
        chat connection before giving up.
IPAD -- Your IP address if you know it.  If this tag is used, it will
        override tintin's attempt to discover your IP itself. (which may not
        always be successful anyway)
DLOD -- The directory to place incoming files using chat file transfer. I
        recommend for saftey sake that this be a sperate directory just for
        file transfers and have set up a directory in tintin++/dl just for
        this purpose.  If you run tintin from the tintin++ directory you will
        have no problems with the default value of dl/
BIND -- This option allows you to take over a port that you had once used
        for chat sessions.  If you set this value to 0 it will allow the
        port to "unbind" itself.  This may take some time and is why this
        option is available.

~CINFO

format:       #cinfo

Displays information describing your chat configuration. Most of this
information was loaded from a file called chat.conf which must be located in
the directory that tt++ was run from.

SEE: chat.conf

~EMOTE

format:       #emote <name> <text>

Sends a personal message to a chat connection like an emote in a mud.
I.E. if your chat name is Joe:

#emote jill likes you.

would send to Jill the text:

Joe likes you.

~EMOTEALL

format:      #emoteall <text>

Sends a message to all of your chat connections like a mud emote.
If your chat name is Joe,

#emoteall likes you.

sends the text too all of your chat connections:

Joe likes you.

~FILECANCEL

format:       #filecancel <name>

End a chat file transfer in progress with the chat connection (name).

SEE: sendfile, chattransfer

~FILESTAT

format:       #filestat <name>

Get transfer statistics on a chat file transfer in progress with the chat
connection (name).

SEE: sendfile, chattransfer
~PING

format":       #ping <name>

Send a message with timing info to chat connection name.  The connection
should return the message as sent and tintin will then dtermine the round
trip time for the message.  Helps determine the network latency for your chat
connections.

~REQUEST

format         #request <name>

Asks the chat connection referenced by (name) to send a list of connections
that it has.  Tintin then reads this list and calls each connection in order
and establishes a chat connection with it.

~SENDFILE

format:        #sendfile <name> <filename>

Assuming that the connection referenced by name is allowing you to send files
to it, this command will send the file you specify to that connection.
Although you may specify any path name you like, once tintin has found and
opened the file you want to send it will remove all path information from
the name before sending the filename to the receiver.  This prevents the
sender from specifying where the file will be saved.  All files sent will be
stored in the receiver's download directory as specified in his chat.conf file.

~UNCHAT

format:        #unchat <name> | *

Disconnects chat sessions.  If a name is specified, it diconnects just that
person from your chat connection list.  If * is specified all connections
will be disconnected.

~HELPVERSION
	Help file was last modified on 7/21/00 by Davin Chan.

~*EOF* 
