help available on the following:
alias action all
antisubstitute bell boss
char echo end
help highlight history
if ignore log
loop map mark
math message nop
path presub redraw
return read savepath
showme snoop speedwalk
split substitute gag
system tick tickoff
tickset ticksize togglesubs
unaction unalias unantisubstitute
ungag unhighlight unpath
unsplit unsubstitute unvariable
verbatim version wizlist
write writesession zap
~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'.
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)}]
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.
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'.
examples:
#action {Grimmy has arrived} {smile grimmy}
If Grimmy enters the room, you will automatically smile at her.
#action {^TICKCOUNTER: 5 seconds} {sleep}
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.
~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.
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
~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.
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.
~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.
~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
New for v1.2, 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.
~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.
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.
~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.
~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.
~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.
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.
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.
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.
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.
examples:
#unsub {%0tells you%1}
remove the highlight for '%0tells you%1'
#unsub *
remove all highlights
#unsub {^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.
examples:
#unvar {hp}
remove the variable $hp
#unvar *
remove all variables
#unvariable {xx*}
remove all variables that start with 'xx'
~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.
~*EOF*