/******************************************************************************
* TinTin++ *
* Copyright (C) 2004 (See CREDITS file) *
* *
* This program is protected under the GNU GPL (See COPYING) *
* *
* This program is free software; you can redistribute it and/or modify *
* it under the terms of the GNU General Public License as published by *
* the Free Software Foundation; either version 2 of the License, or *
* (at your option) any later version. *
* *
* This program is distributed in the hope that it will be useful, *
* but WITHOUT ANY WARRANTY; without even the implied warranty of *
* MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the *
* GNU General Public License for more details. *
* *
* You should have received a copy of the GNU General Public License *
* along with this program; if not, write to the Free Software *
* Foundation, Inc., 59 Temple Place, Suite 330, Boston, MA 02111-1307 USA *
******************************************************************************/
/******************************************************************************
* (T)he K(I)cki(N) (T)ickin D(I)kumud Clie(N)t *
* *
* coded by Igor van den Hoven 2004 *
******************************************************************************/
#include "tintin.h"
struct help_type
{
char * name;
char * text;
};
/*
This help table is a mess, but I got better things to do - Igor
*/
struct help_type help_table[] =
{
{
"ACTION",
"<178>Command<078>: #action <178>{<078>search string<178>}<078> <178>{<078>commands<178>}<078> <178>{<078>priority<178>}<078>\n"
"\n"
" Have tintin search for a certain string of text from the mud, if the\n"
" string is found it will execute the commands. Variables %1 to %99\n"
" are substituted from the input string, and can be used in the command.\n"
"\n"
" If the search string starts with ~, color codes must be matched, which\n"
" you can see by enabling: #config {convert meta} on.\n"
"\n"
" The following Perl compatible regular expression options are available:\n"
"\n"
" ^ force match of start of line.\n"
" $ force match of end of line.\n"
" %1-%99 lazy match of any text, available at %1-%99.\n"
" %0 should be avoided in triggers, and if left alone lists all matches.\n"
" { } embed a raw regular expression, available at %1-%99 + 1.\n"
" [ ] . + | ( ) ? * are treated as normal text unlessed used within\n"
" braces. Keep in mind that { } is replaced with ( ) automatically.\n"
"\n"
" Of the following the (lazy) match is available at %1-%99 + 1\n"
"\n"
" %w match zero to any number of letters.\n"
" %W match zero to any number of non letters.\n"
" %d match zero to any number of digits.\n"
" %D match zero to any number of non digits.\n"
" %s match zero to any number of spaces.\n"
" %S match zero to any number of non spaces.\n"
"\n"
" %? match zero or one character.\n"
" %. match one character.\n"
" %+ match one to any number of characters.\n"
" %* match zero to any number of characters.\n"
"\n"
" %i matching becomes case insensitive.\n"
" %I matching becomes case sensitive (default).\n"
"\n"
" Actions can be triggered by the showme command.\n"
"\n"
"<178>Example<078>: #act {^You are hungry$} {get bread backpack;eat bread}\n"
" Performs 2 commands as you get the hunger message, tintin will not\n"
" be fooled by someone saying 'You are hungry'.\n"
"\n"
"<178>Example<078>: #act {%1 tells you 'hello'} {tell %1 Hello %1. How are you today?}\n"
" This allows you to seem like a nice, attentive, fast typing gentleman.\n"
"\n"
"<178>Example<078>: #act {A puppy barks at you, wagging {his|her|its} tail.} {pat puppy}\n"
" This allows you to be nice to puppies regardless of their sex.\n"
"\n"
"<178>Comment<078>: You can remove an action with the #unaction command.\n"
},
{
"ALIAS",
"<178>Command<078>: #alias <178>{<078>word<178>} {<078>commands<178>}<078>\n"
"\n"
" Defines a word that actually means a different word. Useful for long\n"
" commands repeated often. You can have multiple commands aliased to\n"
" a single word, if you enclose the alias in braces.\n"
"\n"
" If the commands include variables %0-99, these are substituted as\n"
" part of the parsing. %0 is set to all text after the word was input,\n"
" %1 is set to the first word following the aliased word, and %2 is the\n"
" second, and so on.\n"
"\n"
" The word can include the %1 to %99 variables making an alias behave\n"
" like an action for complex input matching.\n"
"\n"
"<178>Example<078>: #alias gb get bread bag\n"
" Typing gb at the prompt would be sent as 'get bread bag'.\n"
"\n"
"<178>Example<078>: #alias ws {wake;stand}\n"
" Since ws aliases a multiple command, you must use the braces.\n"
"\n"
"<178>Example<078>: #alias heal cast 'heal' %1\n"
" Typing 'heal valgar' would be sent as 'cast 'heal' valgar'.\n"
"\n"
"<178>Comment<078>: See '#help action', for more information about triggers.\n"
"\n"
"<178>Comment<078>: You can remove an alias with the #unalias command.\n"
},
{
"ALL",
"<178>Command<078>: #all <178>{<078>string<178>}<078>\n"
"\n"
" Sends a command to all active sessions.\n"
"\n"
"<178>Example<078>: #all quit\n"
" Sends 'quit' to all active sessions.\n"
},
{
"BELL",
"<178>Command<078>: #bell\n"
"\n"
" Sends a beep to your terminal.\n"
"\n"
"<178>Example<078>: #action {tells you} {#bell}\n"
" Will chime every time someone gives you a tell.\n"
},
{
"BREAK",
"<178>Command<078>: #break\n"
"\n"
" The break command can be used inside the #FOREACH, #LOOP, #PARSE,\n"
" #WHILE and #SWITCH statements. When #BREAK is found, tintin will stop\n"
" executing the statement it is currently in and move on to the next.\n"
"\n"
"<178>Example<078>: #while {1} {#math cnt $cnt + 1;#if {$cnt == 20} {#break}}\n"
},
{
"BUFFER",
"<178>Command<078>: #buffer <178>{<078>home<178>|<078>up<178>|<078>down<178>|<078>end<178>|<078>lock<178>|<078>clear<178>|<078>info<178>}<078>\n"
" The buffer command allows you to add macros to scroll in case the\n"
" default bindings do not work. The lock options toggles the\n"
" scrolling state of the screen.\n"
"\n"
" #buffer {find} {number} {text} Jump to the first occasion of text\n"
" or the given occasion by providing the optional number argument.\n"
"\n"
" #buffer {get} {variable} {line} {range} Store the given line or\n"
" range in the given variable.\n"
"\n"
" #buffer {write} {filename} Write the buffer to the given file.\n"
"\n"
"<178>Example<078>: #macro {(press ctrl-v)(press F1)} {#buffer end}\n"
" Associates F1 key to 'scroll buffer to its end' command.\n"
},
{
"CASE",
"<178>Command<078>: #case <178>{<078>conditional<178>}<078> <178>{<078>arguments<178>}<078>\n"
"\n"
" The case command must be used within the switch command. When the\n"
" conditional argument of the case command matches the conditional\n"
" argument of the switch command the body of the case is executed.\n"
},
{
"CHAT",
"<178>Command<078>: #chat <178>{<078>option<178>}<078> <178>{<078>argument<178>}<078>\n"
"\n"
" #chat {init} {port} Initilizes a chat port.\n"
" #chat {name} {name} Sets your chat name.\n"
" #chat {message} {buddy|all} {text} Sends a chat message\n"
"\n"
" #chat {accept} {buddy} Accept a file transfer\n"
" #chat {call} {address} {port} Connect to a buddy\n"
" #chat {cancel} {buddy} Cancel a file transfer\n"
" #chat {color} {color names} Set the default color\n"
" #chat {decline} {buddy} Decline a file transfer\n"
" #chat {dnd} Decline new connections\n"
" #chat {download} {directory} Set your download directory\n"
" #chat {emote} {buddy|all} {text} Send an emote message\n"
" #chat {forward} {buddy} Forward all chat messages\n"
" #chat {forwardall} {buddy} Forward all session output\n"
" #chat {filestat} {buddy} Show file transfer data\n"
" #chat {group} {buddy} {name} Assign a chat group\n"
" #chat {ignore} {buddy} Ignores someone\n"
" #chat {info} Displays your info\n"
" #chat {ip} {address} Changes your IP address\n"
" #chat {paste} {buddy|all} {text} Pastes a block of text\n"
" #chat {peek} {buddy} Show one's public connections\n"
" #chat {ping} {buddy} Display response time\n"
" #chat {private} {buddy|all} Make a connection private\n"
" #chat {public} {buddy|all} Make a connection public\n"
" #chat {reply} {text} Reply to last private message\n"
" #chat {request} {buddy} Request one's public connections\n"
" #chat {send} {buddy|all} {text} Sends a raw data string\n"
" #chat {sendfile} {buddy} {filename} Start a file transfer\n"
" #chat {serve} {buddy} Forward all public chat messages\n"
" #chat {who} Show all connections\n"
" #chat {zap} {buddy} Close a connection\n"
},
{
"CLASS",
"<178>Command<078>: #class <178>{<078>name<178>}<078> <178>{<078>open<178>|<078>close<178>|<078>read filename<178>|<078>write filename<178>|<078>kill<178>}<078>\n"
"\n"
" The {open} option will open a class, closing a previously opened\n"
" class. All triggers added afterwards are assigned to this class.\n"
" The {close} option will close the given class.\n"
" The {read} option will open the class, read, and close afterwards.\n"
" The {write} option will write all triggers of the given class to file.\n"
" The {kill} option will delete all triggers of the given class.\n"
"\n"
" Keep in mind that the kill and read option are very fast allowing\n"
" them to be used to enable and disable classes.\n"
"\n"
"<178>Example<078>: #class extra kill;#class extra read extra.tin\n"
" Deletes all triggers of 'extra' class if any. Read 'extra.tin' file,\n"
" all triggers loaded will be assigned to the fresh new 'extra' class.\n"
},
{
"COLORS",
"<178>Syntax<078>: <<888>xyz> with x, y, z being parameters\n"
"\n"
" Parameter 'x': VT100 code\n"
"\n"
" 0 - Reset all colors and codes to default\n"
" 1 - Bold\n"
" 2 - Dim\n"
" 4 - Underscore\n"
" 5 - Blink\n"
" 7 - Reverse\n"
" 8 - Skip (use previous code)\n"
"\n"
" Parameter 'y': Foreground color\n"
" Parameter 'z': Background color\n"
"\n"
" 0 - Black 5 - Magenta\n"
" 1 - Red 6 - Cyan\n"
" 2 - Green 7 - White\n"
" 3 - Yellow 8 - Skip\n"
" 4 - Blue 9 - Default\n"
"\n"
" For xterm 256 colors support use <<888>aaa> to <<888>fff> for RGB foreground\n"
" colors and <<888>AAA> to <<888>FFF> for RGB background colors. For the grayscale\n"
" foreground colors use <<888>g00> to <<888>g23>, for grayscale background colors\n"
" use <<888>G00> to <<888>G23>.\n"
"\n"
"<178>Example<078>: #showme <<888>115>t<<888>828>e<<888>838>s<<888>848>t<<888>088> <<888>468>!<<888>568>!<<888>088>\n"
" This will show: <115>t<828>e<838>s<848>t<088> <468>!<568>!<088>.\n"
},
{
"CONFIG",
"<178>Command<078>: #config <178>{<078>option<178>}<078> <178>{<078>argument<178>}<078>\n"
"\n"
" This allows you to configure various settings, the settings can be\n"
" written to file with the #write or #writesession command.\n"
"\n"
" If you configure the global session (the one you see as you start up\n"
" tintin) all sessions started will inherite these settings.\n"
"\n"
" It's advised to make a configuration file to read on startup if you\n"
" do not like the default settings.\n"
"\n"
" Config options which aren't listed by default:\n"
"\n"
" #CONFIG {BIG5} {ON|OFF} BIG5 Chinese character handling.\n"
" #CONFIG {CONVERT META} {ON|OFF} Shows color codes and key bindings.\n"
" #CONFIG {COLOR PATCH} {ON|OFF} Fixes color code usage on some muds.\n"
" #CONFIG {DEBUG TELNET} {ON|OFF} Shows telnet negotiations y/n.\n"
" #CONFIG {LOG LEVEL} {LOW|HIGH} LOW logs mud output before triggers.\n"
" #CONFIG {MCCP} {ON|OFF} Enable or disable MCCP support.\n"
},
{
"CONTINUE",
"<178>Command<078>: #continue\n"
"\n"
" The continue command can be used inside the #FOREACH, #LOOP, #PARSE, #WHILE\n"
" and #SWITCH commands. When #CONTINUE is found, tintin will go to the end\n"
" of the command and proceed as normal, which may be to reiterate the command.\n"
"\n"
"<178>Example<078>: #loop 1 10 cnt {#if {$cnt % 2 == 0} {#continue} {say $cnt}}\n"
},
{
"CR",
"<178>Command<078>: #cr\n"
"\n"
" Sends a carriage return to the session. Useful for aliases that need\n"
" extra carriage returns.\n"
},
{
"CURSOR",
"<178>Command<078>: #cursor <178>{<078>option<178>}<078> <178>{<078>argument<178>}<078>\n"
"\n"
" Typing #cursor without an option will show all available cursor\n"
" options. The cursor command's primarly goal is adding customizable\n"
" input editing with macros.\n"
},
{
"DEBUG",
"<178>Command<078>: #debug <178>{<078>listname<178>}<078> <178>{<078>on<178>|<078>off<178>|<078>log<178>}<078>\n"
"\n"
" Toggles a list on or off. With no argument it shows your current\n"
" settings, as well as the list names that you can debug.\n"
"\n"
" If you for example set ACTIONS to ON you will get debug information\n"
" whenever an action is triggered.\n"
"\n"
" #debug {listname} {log} will silently write debugging information to\n"
" the log file, you must be logging in order for this to work.\n"
"\n"
" Not every list has debug support yet.\n"
},
{
"DEFAULT",
"<178>Command<078>: #default <178>{<078>commands<178>}<078>\n"
"\n"
" The default command can only be used within the switch command. When\n"
" the conditional argument of non of the case commands matches the switch\n"
" command's conditional statement the default command is executed.\n"
},
{
"DELAY",
"<178>Command<078>: #delay <178>{<078>seconds<178>}<078> <178>{<078>command<178>}<078>\n"
"<178>Command<078>: #delay <178>{<078>name<178>}<078> <178>{<078>command<178>}<078> <178>{<078>seconds<178>}<078> \n"
"\n"
" Delay allows you to have tintin wait the given amount of seconds\n"
" before executing the given command. tintin won't wait before\n"
" executing following input commands if any.\n"
"\n"
" Floating point precision for miliseconds is possible.\n"
"\n"
"<178>Example<078>: #showme first;#delay {1} {#showme last}\n"
" This will print 'first', and 'last' around one second later.\n"
"\n"
"<178>Comment<078>: If you want to remove a delay with the #undelay command you can add\n"
" a name as the first argument, be aware this changes the syntax.\n"
},
{
"ECHO",
"<178>Command<078>: #echo <178>{<078>format<178>}<078> <178>{<078>argument1<178>} {<078>argument2<178>} {<078>etc<178>}<078>\n"
"\n"
" Echo command displays text on the screen with formatting options. See\n"
" the help file for the format command for more informations.\n"
"\n"
" The echo command does not trigger actions.\n"
"\n"
" As with the #showme command you can split the {format} argument up into\n"
" two braced arguments, in which case the 2nd argument is the row number.\n"
"\n"
"<178>Example<078>: #echo {The current date is %t.} {%Y-%m-%d %H:%M:%S}\n"
" #echo {[%38s][%-38s]} {Hello World} {Hello World}\n"
" #echo {{this is %s on the top row} {-1}} {printed}\n"
},
{
"ELSE",
"<178>Command<078>: #else <178>{<078>commands<178>}<078>\n"
"\n"
" The else statement should follow an #IF or #ELSEIF statement and is only\n"
" called if the proceeding #IF or #ELSEIF is false.\n"
"\n"
"<178>Example<078>: #if {1d2 == 1} {smile};#else {grin}\n"
},
{
"ELSEIF",
"<178>Command<078>: #elseif <178>{<078>conditional<178>}<078> <178>{<078>commands<178>}<078>\n"
"\n"
" The elseif statement should follow an #IF or #ELSEIF statement and is only\n"
" called when the statement is true and the proceeding #IF and #ELSEIF statements\n"
" are false.\n"
"\n"
"<178>Example<078>: #if {1d3 == 1} {smirk};#elseif {1d2 == 1} {snicker}\n"
},
{
"END",
"<178>Command<078>: #end\n"
"\n"
" Terminates tintin and return to unix. On most systems, ctrl-c has\n"
" the same result.\n"
},
{
"ESCAPE CODES",
" You may use the escape character \\ for various special characters.\n"
"\n"
" \\a will beep the terminal.\n"
" \\c will send a control character, \\ca for ctrl-a.\n"
" \\e will start an escape sequence.\n"
" \\n will send a line feed.\n"
" \\r will send a carriage return.\n"
" \\t will send a tab.\n"
" \\x will print a hexadecimal value, \\xFF for example.\n"
" \\x7B will send the '{' character.\n"
" \\x7D will send the '}' character.\n"
"\n"
" Ending a line with \\ will stop tintin from appending a line feed.\n"
" To escape arguments in an alias use %%0 %%1 %%2 etc.\n"
},
{
"EVENT",
"<178>Command<078>: #event <178>{<078>event type<178>}<078>\n"
"\n"
" Events allow you to create triggers for predetermined client events.\n"
" Use #event without an argument to see a list of possible events with\n"
" a brief description. Use #event %* to see the current list of available\n"
" events you can use.\n"
"\n"
" END OF PATH\n"
" IAC <VAR> <VAR>\n"
" IAC SB GMCP <MODULE> %0 data %1 raw data\n"
" IAC SB MSSP %0 variable %1 value\n"
" IAC SB MSDP %0 variable %1 value\n"
" IAC SB MSDP <VAR> %1 value\n"
" IAC SB NEW-ENVIRON %0 variable %1 value\n"
" IAC SB ZMP <VAR> %0 value\n"
" IAC SB <VAR> %0 raw text %1 raw data\n"
" MAP ENTER ROOM %0 new vnum %1 old vnum\n"
" MAP ENTER ROOM <VAR> %0 new vnum %1 old vnum\n"
" MAP EXIT ROOM %0 old vnum %1 new vnum\n"
" MAP EXIT ROOM <VAR> %0 old vnum %1 new vnum\n"
" PROGRAM START %0 client name %1 client version\n"
" PROGRAM TERMINATION\n"
" RECEIVED INPUT %0 raw text\n"
" RECEIVED LINE %0 raw text %1 plain text\n"
" SCREEN RESIZE %0 cols %1 rows\n"
" SEND OUTPUT %0 raw output\n"
" SESSION ACTIVATED %0 name\n"
" SESSION CONNECTED %0 name %1 host %2 ip %3 port\n"
" SESSION DEACTIVATED %0 name\n"
" SESSION DISCONNECTED %0 name %1 host %2 ip %3 port\n"
"\n"
"<178>Example<078>: #event {SESSION CONNECTED} {#read mychar.tin}\n"
"\n"
"<178>Comment<078>: You can remove an event with the #unevent command.\n"
},
{
"FORALL",
"<178>Command<078>: #forall <178>{<078>list<178>}<078> <178>{<078>commands<178>}<078>\n"
"\n"
" List elements must either be separated by braces or semicolons.\n"
"\n"
"<178>Example<078>: #forall {a;b;c;d} {say &0}\n"
"<178>Example<078>: #forall {{a}{b}{c}{d}} {say &0}\n"
" Both equal: say a;say b;say c;say d\n"
},
{
"FOREACH",
"<178>Command<078>: #foreach <178>{<078>list<178>} {<078>variable<178>} {<078>commands<178>}<078>\n"
"\n"
" For each item in the provided list the foreach statement will update\n"
" the given variable and execute the command part of the statement. List\n"
" elements must be separated by braces or semicolons.\n"
"\n"
"<178>Example<078>: #foreach {bob;tim;kim} {name} {tell $name Hello}\n"
"<178>Example<078>: #foreach {{bob}{tim}{kim}} {name} {tell $name Hello}\n"
},
{
"FORMAT",
"<178>Command<078>: #format <178>{<078>variable<178>}<078> <178>{<078>format<178>}<078> <178>{<078>argument1<178>} {<078>argument2<178>} {<078>etc<178>}<078>\n"
"\n"
" Allows you to store a string into a variable in the exact same way\n"
" C's sprintf works with a few enhancements and limitations such as\n"
" no integer operations and a maximum of 20 arguments. If you use format\n"
" inside an alias or action you must escape the %0-9 like: %+4s.\n"
"\n"
"<178>Example<078>: #format {test} {%+9s} {string} pad string with up to 9 spaces\n"
" #format {test} {%-9s} {string} post pad string with up to 9 spaces\n"
" #format {test} {%.8s} {string} copy at most 8 characters\n"
" #format {test} {%a} {number} print corresponding ascii character\n"
" #format {test} {%c} {string} use a highlight color name\n"
" #format {test} {%d} {number} print a number with integer formatting\n"
" #format {test} {%g} {number} perform thousand grouping on {number}\n"
" #format {test} {%h} {string} turn text into a header line\n"
" #format {test} {%l} {string} lowercase text\n"
" #format {test} {%m} {string} perform mathematical calculation\n"
" #format {test} {%n} {name} capitalize the first letter\n"
" #format {test} {%p} {string} strip leading and trailing spaces\n"
" #format {test} {%r} {string} reverse text, hiya = ayih\n"
" #format {test} {%s} {string} print given string\n"
" #format {test} {%t} {format} display time with strftime format\n"
" #format {test} {%u} {string} uppercase text\n"
" #format {test} {%w} {string} wordwrap text\n"
" #format {cols} {%C} {} store the screen width in {cols}\n"
" #format {test} {%L} {string} store the string length in {test}\n"
" #format {rows} {%R} {} store the screen height in {rows}\n"
" #format {time} {%T} {} store the epoch time in {time}\n"
" #format {time} {%U} {} store the micro epoch time in {time}\n"
},
{
"FUNCTION",
"<178>Command<078>: #function <178>{<078>name<178>}<078> <178>{<078>operation<178>}<078>\n"
"\n"
" Functions allow you to execute a script within a line of text, and\n"
" replace the function call with the line of text generated by the\n"
" function.\n"
"\n"
" Be aware that each function should set the $result variable.\n"
"\n"
" To use a function use the @ character before the function name.\n"
" The function arguments should be placed between braces behind the\n"
" function name.\n"
"\n"
" The function itself can use the provided arguments which are stored\n"
" in %1 to %9, with %0 holding all arguments.\n"
"\n"
" Currently you can't use a function from within another function\n"
"\n"
"<178>Example<078>: #function {rnd} {#math {result} {1 d (%2 - %1 + 1) + %1 - 1}}\n"
" #showme A random number between 100 and 200: @rnd{100 200}\n"
"\n"
"<178>Example<078>: #function gettime {#format result %t %H:%M}\n"
" #showme The current time is @gettime{}\n"
"\n"
"<178>Comment<078>: You can remove a function with the #unfunction command.\n"
},
{
"GAG",
"<178>Command<078>: #gag <178>{<078>string<178>}<078>\n"
"\n"
" Removes any line that contains the string.\n"
"\n"
"<178>Comment<078>: See '#help action', for more information about triggers.\n"
"\n"
"<178>Comment<078>: You can remove a gag with the #ungag command.\n"
},
/*
{
"GREETING",
"<068> #<068>##################################################################<068>#\n"
"<068> #<078> <068>#\n"
"<068> #<078> T I N T I N + + "CLIENT_VERSION" <068>#\n"
"<068> #<078> <068>#\n"
"<068> #<078> (<068>T<078>)he k(<068>I<078>)cki(<068>N<078>) (<068>T<078>)ickin d(<068>I<078>)kumud clie(<068>N<078>)t <068> #\n"
"<068> #<078> <068>#\n"
"<068> #<078> Code by Peter Unold, Bill Reis, David A. Wagner, <068>#\n"
"<068> #<078> Rob Ellsworth, Jeremy C. Jack, and Igor van den Hoven. <068>#\n"
"<068> #<078> <068>#\n"
"<068> #<078> 1992, 2011 <068>#\n"
"<068> #<068>##################################################################<068>#<088>\n"
},
*/
{
"GREETING",
"<068> #<068>##################################################################<068>#\n"
"<068> #<078> T I N T I N + + "CLIENT_VERSION" <068>#\n"
"<068> #<078> <068>#\n"
"<068> #<078> (<068>T<078>)he k(<068>I<078>)cki(<068>N<078>) (<068>T<078>)ickin d(<068>I<078>)kumud clie(<068>N<078>)t <068> #\n"
"<068> #<078> <068>#\n"
"<068> #<078> Code by Peter Unold, Bill Reis, David A. Wagner, <068>#\n"
"<068> #<078> Rob Ellsworth, Jeremy C. Jack, and Igor van den Hoven. <068>#\n"
"<068> #<068>##################################################################<068>#<088>\n"
},
{
"GREP",
"<178>Command<078>: #grep <178>[<078>page<178>]<078> <178>{<078>search string<178>}<078>\n"
"\n"
" This command allows you to search for matching lines in your scroll\n"
" back buffer. The amount of matches shown equals your screen size. If\n"
" you want to search back further use the optional page number. You can\n"
" use wildcards for better search results. Be aware the search string\n"
" is case sensitive, which can be disabled by using %i.\n"
"\n"
" By default grep searches from the end of the scrollback buffer to the\n"
" beginning, this can be reversed by using a negative page number.\n"
"\n"
"<178>Example<078>: #grep Bubba tells you\n"
" This will show all occasions where bubba tells you something.\n"
},
{
"HELP",
"<178>Command<078>: #help <178>{<078>subject<178>}<078>\n"
"\n"
" Without an argument #help will list all available help subjects.\n"
"\n"
" Using #help %* will display all help entries.\n"
},
{
"HIGHLIGHT",
"<178>Command<078>: #highlight <178>{<078>string<178>}<078> <178>{<078>color names<178>}<078>\n"
"\n"
" The highlight command is used to allow you to highlight strings of text\n"
" from the mud. Available color names are:\n"
"\n"
" reset, light, faint, underscore, blink, reverse, dim,\n"
" black, red, green, yellow, blue, magenta, cyan, white,\n"
" b black, b red, b green, b yellow, b blue, b magenta, b cyan, b white\n"
"\n"
" The %1-99 variables can be used as 'wildcards' that will match with any\n"
" text. They are useful for highlighting a complete line. The %0 variable\n"
" should never be used in highlights.\n"
"\n"
" You may start the string to highlight with a ^ to only highlight text\n"
" if it begins the line.\n"
"\n"
" Besides color names also <<888>abc> color codes can be used.\n"
"\n"
"<178>Example<078>: #high {Valgar} {reverse}\n"
" Prints every occurrence of 'Valgar' in reverse video.\n"
"\n"
"<178>Example<078>: #high {^You %1} {bold cyan}\n"
" Boldfaces any line that starts with 'You' in cyan.\n"
"\n"
"<178>Example<078>: #high {Bubba} {red underscore blink}\n"
" Highlights the name Bubba as blinking, red, underscored text\n"
"\n"
"<178>Comment<078>: See '#help action', for more information about triggers.\n"
"\n"
"<178>Comment<078>: See '#help substitute', for more advanced color substitution.\n"
"\n"
"<178>Comment<078>: This command only works with ANSI/VT100 terminals or emulators.\n"
"\n"
"<178>Comment<078>: You can remove a highlight with the #unhighlight command.\n"
},
{
"HISTORY",
"<178>Command<078>: #history <178>{<078>delete<178>}<078> Delete the last command.\n"
" #history <178>{<078>insert<178>} {<078>command<178>}<078> Insert a command.\n"
" #history <178>{<078>list<178>}<078> Display the entire command history.\n"
" #history <178>{<078>read<178>} {<078>filename<178>}<078> Read a command history from file.\n"
" #history <178>{<078>write<178>} {<078>filename<178>}<078> Write a command history to file.\n"
"\n"
" Without an argument all available options are shown.\n"
},
{
"IF",
"<178>Command<078>: #if <178>{<078>conditional<178>}<078> <178>{<078>commands if true<178>}<078> <178>{<078>commands if false<178>}<078>\n"
"\n"
" The 'if' command is one of the most powerful commands added since\n"
" TINTIN III. It works similar to an 'if' statement in other languages,\n"
" and is strictly based on the way C handles its conditional statements.\n"
" When an 'if' command is encountered, the conditional statement is\n"
" evaluated, and if TRUE (any non-zero result) the commands are executed.\n"
"\n"
" The 'if' statement is only evaluated if it is read, so you must nest\n"
" the 'if' statement inside another statement (most likely an 'action'\n"
" command). The conditional is evaluated exactly the same as in the\n"
" 'math' command only instead of storing the result, the result is used\n"
" to determine whether to execute the commands.\n"
"\n"
"<178>Example<078>: #action {%0 gives you %1 gold coins.} {#if {%1>5000} {thank %0}}\n"
" If someone gives you more than 5000 coins, thank them.\n"
"\n"
"<178>Comment<078>: See '#help math', for more information.\n"
},
{
"IGNORE",
"<178>Command<078>: #ignore <178>{<078>listname<178>}<078> <178>{<078>on<178>|<078>off<178>}<078>\n"
"\n"
" Toggles a list on or off. With no arguments it shows your current\n"
" settings, as well as the list names that you can ignore.\n"
"\n"
" If you for example set ACTIONS to OFF actions will no longer trigger.\n"
" Not every list can be ignored.\n"
},
{
"INFO",
"<178>Command<078>: #info\n"
"\n"
" Displays all the settings of every tintin list available.\n"
"\n"
"Trivia: Typing: #info cpu will show information about tintin's cpu usage.\n"
},
{
"KILL",
"<178>Command<078>: #kill <178>{<078>list<178><178>} {<078>pattern<178>}<078>\n"
"\n"
" Without an argument, the kill command clears all lists. Useful if\n"
" you don't want to exit tintin to reload your command files.\n"
"\n"
" With one argument a specific list can be cleared.\n"
"\n"
" With two arguments the triggers in the chosen list that match the\n"
" given pattern will be removed.\n"
"\n"
"<178>Example<078>: #kill alias %*test*\n"
},
{
"LINE",
"<178>Command<078>: #line <178>{<078>gag<178>|<078>log<178>|<078>logverbatim<178>}<078> <178>{<078>argument<178>}<078>\n"
"\n"
" #line log {filename} {[text]} Log the current or given line to\n"
" file.\n"
"\n"
" #line logverbatim {filename} {[text]} Like log with no substitutions.\n"
"\n"
" #line gag Gag the next line.\n"
"\n"
" #line substitute {options} {argument} Substitutes the given options:\n"
" variables, functions, colors,\n"
" escapes, secure, in the given\n"
" argument next executes it as a\n"
" command.\n"
"\n"
" #line verbose {argument} Argument is executed verbose.\n"
"\n"
" When using #line log and logging in html format use \\c< \\c> \\c& \\c\" to\n"
" log a literal < > & and \".\n"
},
{
"LIST",
"<178>Command<078>: #list <178>{<078>variable<178>}<078> <178>{<078>option<178>}<078> <178>{<078>argument<178>}<078>\n"
"\n"
" #list {var} {add} {item} Add {item} to the list\n"
" #list {var} {clear} Empty the given list\n"
" #list {var} {create} {item} Create a list using {item}\n"
" #list {var} {delete} {index} {number} Delete the item at {index},\n"
" the {number} is optional.\n"
" #list {var} {insert} {index} {string} Insert {string} at given index\n"
" #list {var} {find} {string} {variable} Return the found index\n"
" #list {var} {get} {index} {variable} Copy an item to {variable}\n"
" #list {var} {set} {index} {string} Change the item at {index}\n"
" #list {var} {size} {variable} Copy list size to {variable}\n"
" #list {var} {sort} {string} Insert item in alphabetic order\n"
"\n"
" The index should be between 1 and the list's length. You can also give\n"
" a negative value, in which case -1 equals the last item in the list, -2\n"
" the second last, etc.\n"
"\n"
" When inserting an item a positive index will prepend the item at the\n"
" given index, while a negative index will append the item.\n"
"\n"
" A length of 0 is returned for an empty or non existant list.\n"
"\n"
" You can directly access elements in a list variable using $var[1],\n"
" $var[2], $var[-1], etc.\n"
},
{
"LOG",
"<178>Command<078>: #log <178>{<078>append<178>|<078>overwrite<178>}<078> <178>{<078>filename<178>}<078>\n"
"\n"
" Logs session to a file, you can set the data type to either plain,\n"
" raw, or html with the config command.\n"
},
{
"LOOP",
"<178>Command<078>: #loop <178>{<078><start><178>} {<078><finish><178>} {<078><variable><178>} {<078>commands<178>}<078>\n"
"\n"
" Like a for statement, loop will loop from start to finish incrementing\n"
" or decrementing by 1 each time through. The value of the loop counter\n"
" is stored in the provided variable, which you can use in the commands.\n"
"\n"
"<178>Example<078>: #loop 1 3 loop {get all $loop.corpse}\n"
" This equals 'get all 1.corpse;get all 2.corpse;get all 3.corpse'.\n"
"\n"
"<178>Example<078>: #loop 3 1 cnt {drop $cnt.key}\n"
" This equals 'drop 3.key;drop 2.key;drop 1.key'.\n"
},
{
"MACRO",
"<178>Command<078>: #macro <178>{<078>key sequence<178>}<078> <178>{<078>commands<178>}<078>\n"
"\n"
" Macros allow you to make tintin respond to function keys.\n"
"\n"
" The key sequence send to the terminal when pressing a function key\n"
" differs for every OS and terminal. To find out what sequence is send\n"
" you can enable the CONVERT META config option.\n"
"\n"
" Another option is pressing ctrl-v, which will enable CONVERT META for\n"
" the next key pressed.\n"
"\n"
"<178>Example<078>: #macro {(press ctrl-v)(press F1)} {#showme \\e[2J;#buffer lock}\n"
" Clear the screen and lock the window when you press F1, useful when the\n"
" boss is near.\n"
"\n"
"<178>Example<078>: #macro {\\eOM} {#cursor enter}\n"
" Makes the keypad's enter key work as an enter in keypad mode.\n"
"\n"
"<178>Comment<078>: Not all terminals properly initialize the keypad key sequences.\n"
" If this is the case you can still use the keypad, but instead of the\n"
" arrow keys use ctrl b, f, p, and n.\n"
"\n"
"<178>Comment<078>: You can remove a macro with the #unmacro command.\n"
},
{
"MAP",
"<178>Command<078>: #map\n"
"\n"
" The map command is the backbone of the auto mapping feature. In order\n"
" to use mapping for muds using 'ne' 'se' 'sw' 'nw' directions, you need\n"
" to create a #pathdir for each direction.\n"
"\n"
" #map at <location> <command>: Execute the command at the location.\n"
"\n"
" #map color <field> value: Sets the map color for the given field.\n"
"\n"
" #map create <size>: Creates a new map and room 1, required to start\n"
" mapping. Default size is 15000 rooms.\n"
"\n"
" #map destroy: Deletes the map.\n"
"\n"
" #map delete <direction>: Deletes the room in the given direction.\n"
"\n"
" #map dig <direction> [new|<vnum>]: Creates an exit in the given\n"
" direction. If no valid direction is given or no existing room\n"
" is found a new room is created. Useful for portal links and\n"
" other alternative forms of transportation. If the 'new'\n"
" argument is provided all existing rooms are ignored. If a\n"
" room vnum is given as the second argument an exit will be\n"
" created to the given room vnum.\n"
"\n"
" #map exit <exit name> <COMMAND|DIRECTION|FLAG|NAME|VNUM> <argument>\n"
" Set the exit data. Useful with a closed door where you can\n"
" set the exit command: '#map exit e command {open east;e}'.\n"
"\n"
" #map exitflag hide: When set, '#map' will not display the map beyond\n"
" this exit. When mapping overlapping areas or areas that aren't\n"
" build consistently you need this flag as well to stop\n"
" auto-linking, unless you use void rooms.\n"
"\n"
" #map explore <direction>: Follows the direction until a dead end or an\n"
" intersection is found. The route is stored in #path and can\n"
" subsequently be used with #walk\n"
"\n"
" #map find <roomname> <exits> <roomdesc> <roomarea> <roomnote> Searches\n"
" for the given room name. If found the shortest path from your\n"
" current location to the target location is calculated. The\n"
" route is stored in #path and can subsequently be used with the\n"
" various #path commands. If <exits> is provided all exits must\n"
" be matched, if <roomdesc>, <roomarea> or <roomnote> is\n"
" provided these are matched as well against the room to be\n"
" found. These options are also available to the goto, and link\n"
" commands.\n"
"\n"
" #map flag static: Will make the map static so new rooms are no longer\n"
" created when walking into an unmapped direction. Useful when\n"
" you're done mapping and regularly bump into walls accidentally\n"
" creating a new room. #map dig etc will still work.\n"
"\n"
" #map flag vtmap: Will enable the vtmap which is shown in the top split\n"
" screen if you have one. You can create a 10 rows high top\n"
" screen by using '#split 10 1'.\n"
"\n"
" #map flag asciigraphics: Draws a smaller but more detailed map that\n"
" displays the ne se sw nw exits and room symbols.\n"
"\n"
" #map flag asciivnums: Display room vnums with asciigraphics enabled.\n"
"\n"
" #map flag vtgraphics: Enables vt line drawing on some terminals\n"
"\n"
" #map goto <room name> [exits]: Takes you to the given room name, if\n"
" you provide exits those must match as well.\n"
"\n"
" #map get <option> <variable> [vnum]: Store a map value into a\n"
" variable, if no vnum is given the current room is used.\n"
"\n"
" #map get roomexits <variable>: Store all room exits into variable.\n"
"\n"
" #map info: Gives information about the map and room you are in.\n"
"\n"
" #map insert <direction> [roomflag]: Insert a room in the given\n"
" direction. Most useful for inserting void rooms.\n"
"\n"
" #map jump <x> <y>: Jump to the given coordinate, which is relative\n"
" to your current room.\n"
"\n"
" #map leave: Makes you leave the map. Useful when entering a maze.\n"
"\n"
" #map legenda <symbols>: The legend exists of 17 decimal numbers which\n"
" represent character symbols used for drawing a map. Binary\n"
" order is used with the n e s w representing bit 1 to 4. The\n"
" first number stands for a no exit room. Number 2 to 16 stand\n"
" for n e ne s ns es nes w nw ew new sw nsw esw nesw. The 17th\n"
" number stands for the room the player is current in.\n"
" The legenda is set by default, but can be adjusted to take\n"
" advantage of fonts with line drawing characters. To check your\n"
" font for drawing characters use:\n"
" #loop 32 255 cnt {#echo {%-3s %a} $cnt $cnt}\n"
"\n"
" #map link <direction> <room name>: Links two rooms. If a valid\n"
" direction is given the link is two way.\n"
"\n"
" #map list <location>: Lists all matching rooms and their distance.\n"
"\n"
" #map map {<x>x<y>} {filename} {a}: shows a map of surrounding rooms.\n"
" The {horizontal x vertical} argument i.e 80x25 is optional,\n"
" and so is the filename argument to log the map output to\n"
" file. The {a} argument causes data to be appended so it can\n"
" easily be tailed with the tail -f <file> shell command.\n"
"\n"
" #map move <direction>: This does the same as an actual movement\n"
" command, updating your location on the map and creating new\n"
" rooms. Useful when you are following someone and want the map\n"
" to follow. You will need to create actions using '#map move',\n"
" for this to work.\n"
"\n"
" #map name <room name>: Allows changing the room name, by default rooms\n"
" have the same name as their internal index number.\n"
"\n"
" #map read <filename>: Will load the given map file.\n"
"\n"
" #map resize <size>: Resize the map, setting the maximum number of\n"
" rooms.\n"
"\n"
" #map return: Returns you to your last known room after leaving the map\n"
" or loading a map.\n"
"\n"
" #map roomflag avoid: When set, '#map find' will avoid a route leading\n"
" through that room. Useful when you want to avoid death traps.\n"
" #map roomflag hide: When set, '#map' will not display the map beyond\n"
" this room. When mapping overlapping areas or areas that aren't\n"
" build consistently you need this flag as well to stop\n"
" auto-linking, unless you use void rooms.\n"
" #map roomflag leave: When entering a room with this flag, you will\n"
" automatically leave the map. Useful when set at the entrance\n"
" of an unmappable maze.\n"
" #map roomflag void: When set the room becomes a spacing room that can\n"
" be used to connect otherwise overlapping areas. A void room\n"
" should only have two exits. When entering a void room you are\n"
" moved to the connecting room until you enter a non void room.\n"
" #map roomflag static: When set the room will no longer be autolinked\n"
" when walking around. Useful for mapping mazes.\n"
"\n"
" #map run <room name> [delay]: Calculates the shortest path to the\n"
" destination and walks you there. The delay is optional and\n"
" requires using braces. Besides the room name a list of\n"
" exits can be provided for more precise matching.\n"
"\n"
" #map set <option> <value> [vnum]: Set a map value for your current\n"
" room, or given room if a room vnum is provided.\n"
"\n"
" #map travel <direction> <delay>: Follows the direction until a dead end\n"
" or an intersection is found. Use braces around the direction\n"
" if you use the delay, which will add the given delay between\n"
" movements\n"
"\n"
" #map undo: Will undo your last move. If this created a room or a link\n"
" they will be deleted, otherwise you'll simply move back a\n"
" room. Useful if you walked into a non existant direction.\n"
"\n"
" #map uninsert <direction>: Exact opposite of the insert command.\n"
"\n"
" #map unlink <direction> [both]: Will remove the exit, this isn't two\n"
" way so you can have the map properly display no exit rooms and\n"
" mazes.\n"
" If you use the both argument the exit is removed two-ways.\n"
"\n"
" #map write <filename>: Will save the map.\n"
},
{
"MATH",
"<178>Command<078>: #math <178>{<078>variable<178>}<078> <178>{<078>expression<178>}<078>\n"
"\n"
" Performs math operations and stores the result in a variable. The math\n"
" follows a C-like precedence, as follows, with the top of the list\n"
" having the highest priority.\n"
"\n"
" Operators Priority Function\n"
" ------------------------------------------------\n"
" ! 0 logical not\n"
" ~ 0 bitwise not\n"
" * 1 integer multiply\n"
" / 1 integer divide\n"
" % 1 integer modulo\n"
" d 1 integer random dice roll\n"
" + 2 integer addition\n"
" - 2 integer subtraction\n"
" << 3 bitwise shift\n"
" >> 3 bitwise shift\n"
" > 4 logical greater than\n"
" >= 4 logical greater than or equal\n"
" < 4 logical less than\n"
" <= 4 logical less than or equal\n"
" == 5 logical equal (can use regex)\n"
" != 5 logical not equal (can use regex)\n"
" & 6 bitwise and\n"
" ^ 7 bitwise xor\n"
" | 8 bitwise or\n"
" && 9 logical and\n"
" ^^ 10 logical xor\n"
" || 11 logical or\n"
"\n"
" True is any non-zero number, and False is zero. Parentheses () have\n"
" highest precedence, so inside the () is always evaluated first.\n"
" Strings must be enclosed in \" \" and use regex with == and !=,\n"
" in the case of <= and >= the alphabetic order is compared.\n"
"\n"
"<178>Example<078>: #math {heals} {$mana / 40}\n"
" Assuming there is a variable $mana, divides its value by 40 and stores\n"
" the result in $heals.\n"
"\n"
"<178>Example<078>: #action {^You receive %0 experience} {updatexp %0}\n"
" #alias updatexp {#math {xpneed} {$xpneed - %0}\n"
" Let's say you have a variable which stores xp needed for your next\n"
" level. The above will modify that variable after every kill, showing\n"
" the amount still needed.\n"
"\n"
"<178>Example<078>: #action {%0 tells %1}\n"
" {#if {\"\%0\" == \"Bubba\" && $afk} {reply I'm away, my friend.}}\n"
" When you are away from keyboard, it will only reply to your friend.\n"
},
{
"MESSAGE",
"<178>Command<078>: #message <178>{<078>listname<178>}<078> <178>{<078>on<178>|<078>off<178>}<078>\n"
"\n"
" This will show the message status of all your lists if typed without an\n"
" argument. If you set for example VARIABLES to OFF you will no longer be\n"
" spammed when correctly using the #VARIABLE and #UNVARIABLE commands.\n"
},
{
"NOP",
"<178>Command<078>: #nop <178>{<078>whatever<178>}<078>\n"
"\n"
" Short for 'no operation', and is ignored by the client. It is useful\n"
" for commenting in your coms file, any text after the nop and before a\n"
" semicolon or end of line is ignored. You shouldn't put braces { } in it\n"
" though, unless you close them properly.\n"
"\n"
"<178>Comment<078>: By using braces you can comment out multiple lines of code in a script\n"
" file.\n"
"\n"
" For commenting out an entire trigger and especially large sections of\n"
" triggers you would want to use /* text */\n"
"\n"
"<178>Example<078>: #nop This is the start of my script file.\n"
},
{
"PARSE",
"<178>Command<078>: #parse <178>{<078>string<178>} {<078>variable<178>} {<078>commands<178>}<078>\n"
"\n"
" Like the loop statement, parse will loop from start to finish through\n"
" the given string. The value of the current character is stored in the\n"
" provided variable.\n"
"\n"
"<178>Example<078>: #parse {hello world} {char} {#showme $char}\n"
},
{
"PATH",
"<178>Command<078>: #path <178>{<078>del<178>|<078>end<178>|<078>ins<178>|<078>load<178>|<078>map<178>|<078>new<178>|<078>run<178>|<078>save<178>|<078>walk<178>}<078> <178>{<078>argument<178>}<078>\n"
"\n"
" #path del: Will delete the last move of the path.\n"
" #path end: Movement commands are no longer added to the path.\n"
" #path ins: Add the given argument to the path.\n"
" #path load: Load the given variable as the new path.\n"
" #path map: Display the so far created path.\n"
" #path new: Movement commands will be added to the path.\n"
" #path run: Enter all the steps of the current path, with\n"
" an optional given delay.\n"
" #path save: Save the created path to a variable. You must specify\n"
" whether you want to save the path forward or backward.\n"
" #path walk: Take one step forward of the current path. You can walk\n"
" backwards using #path walk backwards.\n"
"\n"
"<178>Example<078>: #path ins {unlock n;open n} {unlock s;open s}\n"
},
{
"PATHDIR",
"<178>Command<078>: #pathdir <178>{<078>dir<178>}<078> <178>{<078>reversed dir<178>}<078> <178>{<078>coord<178>}<078>\n"
"\n"
" By default tintin sets the most commonly used movement commands\n"
" meaning you generally don't really have to bother with pathdirs.\n"
" Pathdirs are used by the #path and #map commands.\n"
"\n"
" The first argument is a direction, the second argument is the reversed\n"
" direction. The reverse direction of north is south, etc.\n"
"\n"
" The third argument is a spatial coordinate. In general, each cardinal\n"
" direction should have a unique value which is a power of two (e.g. 1, 2,\n"
" 4, 8, 16, 32, 64, etc). The exception is for compound directions, whose\n"
" value should be the sum of the values for each component direction. For\n"
" example, if the third value for 'n' is 1, and 'e' is 2, then you would\n"
" want 'ne' to have a value of 3 (1 + 2). This value is required for the\n"
" #map functionality to work.\n"
"\n"
"<178>Example<078>: #pathdir {ue} {dw} {18}\n"
" #pathdir {dw} {ue} {40}\n"
"\n"
"<178>Comment<078>: You can remove a pathdir with the #unpathdir command.\n"
},
{
"PROMPT",
"<178>Command<078>: #prompt <178>{<078>text<178>}<078> <178>{<078>new text<178>}<078> <178>{<078>row #<178>}<078>\n"
"\n"
" Prompt is a feature for split window mode (see #help split), which\n"
" will take the status prompt from the mud, and display it on the status\n"
" line of the split window. You would define <string> the same way you\n"
" would a substitution (see #help substitute). The row number is\n"
" optional if you use a non standard split mode. In which case a\n"
" positive number draws #row lines above your cursor, and a negative\n"
" number draws #row lines below your topline.\n"
"\n"
"<178>Comment<078>: See '#help action', for more information about triggers.\n"
"\n"
"<178>Comment<078>: You can remove a prompt with the #unprompt command.\n"
},
{
"READ",
"<178>Command<078>: #read <178>{<078>filename<178>}<078>\n"
"\n"
" Reads a commands file into memory. The coms file is merged in with\n"
" the currently loaded commands. Duplicate commands are overwritten.\n"
"\n"
" If you uses braces, { and } you can use several lines for 1 commands.\n"
" This however means you must always match every { with a } for the read\n"
" command to work.\n"
"\n"
" You can comment out triggers using /* text */\n"
},
{
"REGEXP",
"<178>Command<078>: #regexp <178>{<078>string<178>}<078> <178>{<078>expression<178>}<078> <178>{<078>true<178>}<078> <178>{<078>false<178>}<078>\n"
"\n"
" Compares the string to the given regular expression.\n"
"\n"
" Variables are stored in &1 to &99 with &0 holding the matched substring.\n"
"\n"
" ^ force match of start of string.\n"
" $ force match of end of string.\n"
" %1-%99 lazy match of any text, available at &1-&99.\n"
" %0 should be avoided in triggers, and if left alone &0 lists all matches.\n"
" { } embed a raw regular expression, available at last &1-&99 + 1.\n"
" [ ] . + | ( ) ? * are treated as normal text unlessed used within\n"
" braces. Keep in mind that { } is replaced with ( ) automatically.\n"
"\n"
" Of the following the lazy match is available at last &1-&99 + 1.\n"
"\n"
" %w match zero to any number of letters.\n"
" %W match zero to any number of non letters.\n"
" %d match zero to any number of digits.\n"
" %D match zero to any number of non digits.\n"
" %s match zero to any number of spaces.\n"
" %S match zero to any number of non spaces.\n"
"\n"
" %? match zero or one character.\n"
" %. match one character.\n"
" %+ match one to any number of characters.\n"
" %* match zero to any number of characters.\n"
"\n"
" %i matching becomes case insensitive.\n"
" %I matching becomes case sensitive (default).\n"
"\n"
"<178>Example<078>: #regexp {bli bla blo} {bli {.*} blo} {#showme &1}\n"
},
{
"REPLACE",
"<178>Command<078>: #replace <178>{<078>variable<178>}<078> <178>{<078>oldtext<178>}<078> <178>{<078>newtext<178>}<078>\n"
"\n"
" Searches the variable text replacing each occurance of 'oldtext' with\n"
" 'newtext'.\n"
},
{
"RETURN",
"<178>Command<078>: #return <178>{<078>text<178>}<078>\n"
"\n"
" This command can be used to break out of a command string being executed.\n"
" If used inside a #function you can use #return with an argument to both\n"
" break out of the function and set the result variable.\n"
},
{
"RUN",
"<178>Command<078>: #run <178>{<078>session name<178>}<078> <178>{<078>shell command<178>}<078>\n"
"\n"
" The run command works much like the system command except that it\n"
" runs the command in a pseudo terminal. The run command also creates\n"
" a session that treats the given shell command as a mud server. This\n"
" allows you to run ssh, as well as any other shell application, with\n"
" full tintin scripting capabilities\n"
"\n"
"<178>Example<078>: #run {somewhere} {ssh someone@somewhere.com}\n"
"<178>Example<078>: #run {something} {tail -f chats.log}\n"
},
{
"SCAN",
"<178>Command<078>: #scan <178>{<078>filename<178>}<078>\n"
"\n"
" The scan command reads in a file and sends its content to the screen\n"
" as if it was send by a mud. After using scan you can use page-up and\n"
" down to view the file.\n"
"\n"
" This command is useful to convert ansi color files to html or viewing\n"
" raw log files.\n"
"\n"
" Reads in a file and sends it to the screen as if it was send by a mud.\n"
" This is useful to convert ansi color file to html or viewing log file.\n"
},
{
"SCRIPT",
"<178>Command<078>: #script <178>{<078>variable<178>}<178> {<078>shell command<178>}<078>\n"
"\n"
" The script command works much like the system command except that it\n"
" treats the generated echos as commands if no variable is provided.\n"
"\n"
" This is useful for running php, perl, ruby, and python scripts. You\n"
" can run these scrips either from file or from within tintin if the\n"
" scripting language allows this.\n"
"\n"
" If you provide a variable the output of the script is stored as a list.\n"
"\n"
"<178>Example<078>: #script {ruby -e 'print \"#showme hello world\"'}\n"
"<178>Example<078>: #script {python -c 'print \"#showme hello world\"'}\n"
"<178>Example<078>: #script {php -r 'echo \"#showme hello world\"'}\n"
"<178>Example<078>: #script {path} {pwd};#showme The path is $path[1].\n"
},
{
"SEND",
"<178>Command<078>: #send <178>{<078>text<178>}<078>\n"
"\n"
" Sends the text directly to the MUD, useful if you want to start with an\n"
" escape code.\n"
},
{
"SESSION",
"<178>Command<078>: #session <178>{<078>name<178>}<078> <178>{<078>host<178>}<078> <178>{<078>port<178>}<078>\n"
"\n"
" Starts a telnet session with the given name, host and port. The name\n"
" can be anything you want, except the name of an already existant\n"
" session or a tintin command.\n"
"\n"
" Without an argument #session shows the currently defined sessions.\n"
"\n"
" If you have more than one session, you can use the following commands:\n"
" #session {-|+|number}: Switches between sessions.\n"
" #{name}: Switches to a session with the given name.\n"
" #{name} {command}: Executes a command with the given session without\n"
" changing the active session.\n"
"\n"
" The startup session is named 'gts' and can be used for relog scripts.\n"
"\n"
"<178>Example<078>: #act {^#SESSION '%0' DIED.^} {#gts #delay 10 #ses %0 mymud.com 4321}\n"
},
{
"SHOWME",
"<178>Command<078>: #showme <178>{<078>string<178>}<078> <178>{<078>row<178>}<078>\n"
"\n"
" Display the string to the terminal, do not send to the mud. Useful for\n"
" status, warnings, etc. The {row} number is optional and works the same\n"
" way as the row number of the #prompt trigger.\n"
"\n"
" Actions can be triggered by the showme command.\n"
"\n"
"<178>Example<078>: #action {%0 ultraslays you.}\n"
" {#showme {###### ARGH! We were ultraslayed by %0 ######};#gagline}\n"
" Emphasis ultraslaying.\n"
},
{
"SNOOP",
"<178>Command<078>: #snoop <178>{<078>session name<178>}<078>\n"
"\n"
" If there are multiple sessions active, this command allows you to see\n"
" what is going on the the sessions that are not currently active. The\n"
" line of text from other sessions will be prefixed by the session's name.\n"
"\n"
" You can toggle off snoop mode by executing #snoop a second time.\n"
},
{
"SPEEDWALK",
" <078>Speedwalking allows you to type multiple directions not separated by\n"
" semicolons, and now it lets you prefix a direction with a number, to\n"
" signify how many times to go that direction. You can turn it on/off\n"
" with #config.\n"
"\n"
"<178>Example<078>: Without speedwalk, you have to type:\n"
" s;s;w;w;w;w;w;s;s;s;w;w;w;n;n;w\n"
" With speedwalk, you only have to type:\n"
" 2s5w3s3w2nw\n"
},
{
"SPLIT",
"<178>Command<078>: #split <178>{<078>top border height<178>}<078> <178>{<078>bottom border height<178>}<078>\n"
"\n"
" This option only works with a VT100 emulator, this allows you to set up\n"
" a screen. The keyboard input will be displayed in the bottom line,\n"
" while mud text is displayed in the main window. This requires a fairly\n"
" decent emulator, but works on most I have tested.\n"
"\n"
" | Top border (can be ommited, height customizable)\n"
" | Mud text\n"
" | Bottom border (height customizable, at least one line)\n"
" | Input line\n"
"\n"
" If used without an argument, the top border will be ommited, and the\n"
" bottom border's height will be set to one line.\n"
"\n"
" If you want a different split setting, because you want a two lines\n"
" thick split, or like having a blank line at the top of the screen\n"
" to display something you can set the top and bottom line with the\n"
" additional arguments.\n"
"\n"
"<178>Example<078>: #split\n"
" If tintin has determined that you have a screen of 30 rows, it will\n"
" set the main window from line #1 to line #28.\n"
"\n"
"<178>Comment<078>: You can display text on the split line(s) with the #prompt and\n"
" #showme {line} {row} command.\n"
"\n"
"<178>Comment<078>: You can remove split mode with the #unsplit command.\n"
},
{
"STATEMENTS",
" TinTin++ knows the following statements.\n"
"<078>\n"
" #break\n"
" #case {value} {true}\n"
" #continue\n"
" #default {commands}\n"
" #else {commands}\n"
" #elseif {expression} {true}\n"
" #foreach {list} {variable} {commands}\n"
" #if {expression} {true}\n"
" #loop {min} {max} {variable} {commands}\n"
" #parse {string} {variable} {commands}\n"
" #return {value}\n"
" #switch {expression} {commands}\n"
" #while {expression} {commands}\n"
},
{
"SUBSTITUTE",
"<178>Command<078>: #substitute <178>{<078>text<178>}<078> <178>{<078>new text<178>}<078>\n"
"\n"
" Allows you to replace original text from the mud with different text.\n"
" This is helpful for complex coloring and making things more readable.\n"
" The %1-%99 variables can be used to capture text and use it as part of\n"
" the new output, and the ^ char is valid to only check the beginning of\n"
" the line for the text specified.\n"
"\n"
" If only one argument is given, all active substitutions that match the\n"
" strings are displayed. The '%*' char is valid in this instance. See\n"
" '#help regex', for advanced wildcard information.\n"
"\n"
" If no argument is given, all subs are displayed.\n"
"\n"
"<178>Example<078>: #sub {Zoe} {ZOE}\n"
" Any instance of Zoe will be replaced with ZOE.\n"
"\n"
"<178>Example<078>: #sub {~\\e[0;34m} {\\e[1;34m}\n"
" Replace generic dark blue color codes with bright blue ones.\n"
"\n"
"<178>Example<078>: #sub {%1massacres%2} {<<888>018>%1<<888>118>MASSACRES<<888>018>%2}\n"
" Replaces all occurrences of 'massacres' with 'MASSACRES' in red.\n"
"\n"
"<178>Comment<078>: See '#help action', for more information about triggers.\n"
"\n"
"<178>Comment<078>: See '#help colors', for more information.\n"
"\n"
"<178>Comment<078>: You can remove a substitution with the #unsubstitute command.\n"
},
{
"SUSPEND",
"<178>Command<078>: #suspend\n"
"\n"
" Temporarily suspends tintin and returns you to your shell. The\n"
" effect of this command is exactly as if you had typed control-z.\n"
" To return to tintin, type 'fg' at the shell prompt.\n"
"\n"
" While suspended your tintin sessions will freeze. To keep a\n"
" suspended session running use the screen utility program and\n"
" have it detach the session.\n"
},
{
"SWITCH",
"<178>Command<078>: #switch <178>{<078>conditional<178>}<078> <178>{<078>arguments<178>}<078>\n"
"\n"
" The switch command works similar to the switch statement in other\n"
" languages. When the 'switch' command is encountered its body is parsed\n"
" and each 'case' command found will be compared to the conditional\n"
" argument of the switch and executed if there is a match.\n"
"\n"
" If the 'default' command is found and no 'case' statement has been\n"
" matched the default command's argument is executed.\n"
"\n"
"<178>Example<078>: #switch {1d4} {#case 1 cackle;#case 2 smile;#default giggle}\n"
},
{
"SYSTEM",
"<178>Command<078>: #system <178>{<078>command<178>}<078>\n"
"\n"
" Executes the command specified as a shell command.\n"
},
{
"TAB",
"<178>Command<078>: #tab <178>{<078>word<178>}<078>\n"
"\n"
" Adds a word to the tab completion list, alphabetically sorted.\n"
"\n"
" If no tabs are defined tintin will use the scrollback buffer\n"
" for auto tab completion.\n"
"\n"
"<178>Comment<078>: You can remove a tab with the #untab command.\n"
},
{
"TEXTIN",
"<178>Command<078>: #textin <178>{<078>filename<178>}<078> <178>{<078>delay<178>}<078>\n"
"\n"
" Textin allows the user to read in a file, and send its contents\n"
" directly to the mud. Useful for doing online creation, or message\n"
" writing. The delay has a micro second precision and is cumulatively\n"
" applied to each outgoing line.\n"
},
{
"TICKER",
"<178>Command<078>: #ticker <178>{<078>name<178>}<078> <178>{<078>commands<178>}<078> <178>{<078>interval in seconds<178>}<078>\n"
"\n"
" Executes given command every # of seconds.\n"
"\n"
"<178>Comment<078>: You can remove a ticker with the #unticker command.\n"
},
{
"VARIABLE",
"<178>Command<078>: #variable <178>{<078>variable name<178>}<078> <178>{<078>text to fill variable<178>}<078>\n"
"\n"
" Variables differ from the %0-99 arguments in the fact that you can\n"
" specify a full word as a variable, and they stay in memory for the\n"
" full session unless they are changed. They can be saved in the\n"
" coms file, and can be set to different values if you have two or\n"
" more sessions running at the same time. Variables are global for\n"
" each session and can be accessed by adding a $ before the variable\n"
" name.\n"
"\n"
"<178>Example<078>: #alias {target} {#var target %0}\n"
" #alias {x} {flame $target}\n"
"\n"
" The name of a variable must exist of only letters and numbers in\n"
" order to be substituted. If you do not meet these requirements do\n"
" not panic, simply encapsulate the variable in braces:\n"
"\n"
"<178>Example<078>: #variable {cool website} {http://tintin.sourceforge.net}\n"
" #chat I was on ${cool website} yesterday!.\n"
"\n"
" Variables can be nested using brackets:\n"
"\n"
"<178>Example<078>: #var hp[self] 34;#var hp[target] 46\n"
"\n"
" You can see the first nest of a variable using $variable[+1] and the\n"
" last nest using $variable[-1]. Using $variable[-2] will report the\n"
" second last variable, and so on. To show all indices use $variable[].\n"
" To show all values use $variable[%*] or a less generic regex.\n"
"\n"
"<178>Comment<078>: To see the internal index of a variable use &<variable name>\n"
"\n"
"<178>Comment<078>: A non existent nested variable will report itself as 0.\n"
"\n"
"<178>Comment<078>: You can remove a variable with the #unvariable command.\n"
},
{
"WRITE",
"<178>Command<078>: #write <178>{<078>filename<178>}<078>\n"
"\n"
" Writes all current actions, aliases, subs, highlights, and variables\n"
" to a command file, specified by filename.\n"
},
{
"ZAP",
"<178>Command<078>: #zap {[session]}\n"
"\n"
" Kill your current session. If there is no current session, it will\n"
" cause the program to terminate. If you provide an argument it'll zap\n"
" the given session instead.\n"
},
{
"",
""
}
};
DO_COMMAND(do_help)
{
char left[BUFFER_SIZE], add[BUFFER_SIZE], buf[BUFFER_SIZE], *ptf, *pto;
int cnt, found;
arg = get_arg_in_braces(arg, left, TRUE);
if (*left == 0)
{
for (cnt = add[0] = 0 ; *help_table[cnt].name != 0 ; cnt++)
{
if ((int) strlen(add) + 19 > ses->cols)
{
tintin_puts2(ses, add);
add[0] = 0;
}
cat_sprintf(add, "%19s", help_table[cnt].name);
}
tintin_puts2(ses, add);
}
else
{
found = FALSE;
for (cnt = 0 ; *help_table[cnt].name != 0 ; cnt++)
{
if (is_abbrev(left, help_table[cnt].name) || atoi(left) == cnt + 1 || match(ses, help_table[cnt].name, left))
{
substitute(ses, help_table[cnt].text, buf, SUB_COL);
pto = buf;
while (*pto)
{
ptf = strchr(pto, '\n');
if (ptf == NULL)
{
break;
}
*ptf++ = 0;
tintin_puts3(ses, pto);
pto = ptf;
}
// tintin_puts2(ses, "");
found = TRUE;
if (is_abbrev(left, help_table[cnt].name))
{
break;
}
}
}
if (found == FALSE)
{
tintin_printf2(ses, "No help found for '%s'", left);
}
}
return ses;
}