mudclient
/
tintin


			
							123456789101112131415161718192021222324252627282930313233343536373839404142434445464748495051525354555657585960616263646566676869707172737475767778798081828384858687888990919293949596979899100101102103104105106107108109110111112113114115116117118119120121122123124125126127128129130131132133134135136137138139140141142143144145146147148149150151152153154155156157158159160161162163164165166167168169170171172173174175176177178179180181182183184185186187188189190191192193194195196197198199200201202203204205206207208209210211212213214215216217218219220221222223224225226227228229230231232233234235236237238239240241242243244245246247248249250251252253254255256257258259260261262263264265266267268269270271272273274275276277278279280281282283284285286287288289290291292293294295296297298299300301302303304305306307308309310311312313314315316317318319320321322323324325326327328329330331332333334335336337338339340341342343344345346347348349350351352353354355356357358359360361362363364365366367368369370371372373374375376377378379380381382383384385386387388389390391392393394395396397398399400401402403404405406407408409410411412413414415416417418419420421422423424425426427428429430431432433434435436437438439440441442443444445446447448449450451452453454455456457458459460461462463464465466467468469470471472473474475476477478479480481482483484485486487488489490491492493494495496497498499500501502503504505506507508509510511512513514515516517518519520521522523524525526527528529530531532533534535536537538539540541542543544545546547548549550551552553554555556557558559560561562563564565566567568569570571572573574575576577578579580581582583584585586587588589590591592593594595596597598599600601602603604605606607608609610611612613614615616617618619620621622623624625626627628629630631632633634635636637638639640641642643644645646647648649650651652653654655656657658659660661662663664665666667668669670671672673674675676677678679680681682683684685686687688689690691692693694695696697698699700701702703704705706707708709710711712713714715716717718719720721722723724725726727728729730731732733734735736737738739740741742743744745746747748749750751752753754755756757758759760761762763764765766767768769770771772773774775776777778779780781782783784785786787788789790791792793794795796797798799800801802803804805806807808809810811812813814815816817818819820821822823824825826827828829830831832833834835836837838839840841842843844845846847848849850851852853854855856857858859860861862863864865866867868869870871872873874875876877878879880881882883884885886887888889890891892893894895896897898899900901902903904905906907908909910911912913914915916917918919920921922923924925926927928929930931932933934935936937938939940941942943944945946947948949950951952953954955956957958959960961962963964965966967968969970971972973974975976977978979980981982983984985986987988989990991992993994995996997998999100010011002100310041005100610071008100910101011101210131014101510161017101810191020102110221023102410251026102710281029103010311032103310341035103610371038103910401041104210431044104510461047104810491050105110521053105410551056105710581059106010611062106310641065106610671068106910701071107210731074107510761077107810791080108110821083108410851086108710881089109010911092109310941095109610971098109911001101110211031104110511061107110811091110111111121113111411151116111711181119112011211122112311241125112611271128112911301131113211331134113511361137113811391140114111421143114411451146114711481149115011511152115311541155115611571158115911601161116211631164116511661167116811691170117111721173117411751176117711781179118011811182118311841185118611871188118911901191119211931194119511961197119811991200120112021203120412051206120712081209121012111212121312141215121612171218121912201221122212231224122512261227122812291230123112321233123412351236123712381239124012411242124312441245124612471248124912501251125212531254125512561257125812591260126112621263126412651266126712681269127012711272127312741275127612771278127912801281128212831284128512861287128812891290129112921293129412951296129712981299130013011302130313041305130613071308130913101311131213131314131513161317131813191320132113221323132413251326132713281329133013311332133313341335133613371338133913401341134213431344134513461347134813491350135113521353135413551356135713581359136013611362136313641365136613671368136913701371137213731374137513761377137813791380138113821383138413851386138713881389139013911392139313941395139613971398139914001401140214031404140514061407140814091410141114121413141414151416141714181419142014211422142314241425142614271428142914301431143214331434143514361437143814391440144114421443144414451446144714481449145014511452145314541455145614571458145914601461146214631464146514661467146814691470147114721473147414751476147714781479148014811482148314841485148614871488148914901491149214931494149514961497149814991500150115021503150415051506150715081509151015111512151315141515151615171518151915201521152215231524152515261527152815291530153115321533153415351536153715381539154015411542154315441545154615471548154915501551155215531554155515561557155815591560156115621563156415651566156715681569157015711572157315741575157615771578157915801581158215831584158515861587158815891590159115921593159415951596159715981599160016011602160316041605160616071608160916101611161216131614161516161617161816191620162116221623162416251626162716281629163016311632163316341635163616371638163916401641164216431644164516461647164816491650165116521653165416551656165716581659166016611662166316641665166616671668166916701671167216731674167516761677167816791680168116821683168416851686168716881689169016911692169316941695169616971698169917001701170217031704170517061707170817091710171117121713171417151716171717181719172017211722172317241725172617271728172917301731173217331734173517361737173817391740174117421743174417451746174717481749175017511752175317541755175617571758175917601761176217631764176517661767176817691770177117721773177417751776177717781779178017811782178317841785178617871788178917901791179217931794179517961797179817991800180118021803180418051806180718081809181018111812181318141815181618171818181918201821182218231824182518261827182818291830183118321833183418351836183718381839184018411842184318441845184618471848184918501851185218531854185518561857185818591860186118621863186418651866186718681869187018711872187318741875187618771878187918801881188218831884188518861887188818891890189118921893189418951896189718981899190019011902190319041905190619071908190919101911191219131914191519161917191819191920192119221923192419251926192719281929193019311932193319341935193619371938193919401941194219431944194519461947194819491950195119521953195419551956195719581959196019611962196319641965196619671968196919701971197219731974197519761977197819791980198119821983198419851986198719881989199019911992199319941995199619971998199920002001200220032004200520062007200820092010201120122013201420152016201720182019202020212022202320242025202620272028202920302031203220332034203520362037203820392040204120422043204420452046204720482049205020512052205320542055205620572058205920602061206220632064206520662067206820692070207120722073207420752076207720782079208020812082208320842085208620872088208920902091209220932094209520962097209820992100210121022103210421052106210721082109211021112112211321142115211621172118211921202121212221232124212521262127212821292130213121322133213421352136213721382139214021412142214321442145214621472148214921502151215221532154215521562157215821592160216121622163216421652166216721682169217021712172217321742175217621772178217921802181218221832184218521862187218821892190219121922193219421952196219721982199220022012202220322042205220622072208220922102211221222132214221522162217221822192220222122222223222422252226222722282229223022312232223322342235223622372238223922402241224222432244224522462247224822492250225122522253225422552256225722582259226022612262226322642265226622672268226922702271227222732274227522762277227822792280228122822283228422852286228722882289229022912292229322942295229622972298229923002301230223032304230523062307230823092310231123122313231423152316231723182319232023212322232323242325232623272328232923302331233223332334233523362337233823392340234123422343234423452346234723482349235023512352235323542355235623572358235923602361236223632364236523662367236823692370237123722373237423752376237723782379238023812382238323842385238623872388238923902391239223932394239523962397239823992400240124022403240424052406240724082409241024112412241324142415241624172418241924202421242224232424242524262427242824292430243124322433243424352436243724382439244024412442244324442445244624472448244924502451245224532454245524562457245824592460246124622463246424652466246724682469247024712472247324742475247624772478247924802481248224832484248524862487248824892490249124922493249424952496249724982499250025012502250325042505250625072508250925102511251225132514251525162517251825192520252125222523252425252526252725282529253025312532253325342535253625372538253925402541254225432544254525462547254825492550255125522553255425552556255725582559256025612562256325642565256625672568256925702571257225732574257525762577257825792580258125822583258425852586258725882589259025912592259325942595259625972598259926002601260226032604260526062607260826092610261126122613261426152616261726182619262026212622262326242625262626272628262926302631263226332634263526362637263826392640264126422643264426452646264726482649265026512652265326542655265626572658265926602661266226632664266526662667266826692670267126722673267426752676267726782679268026812682268326842685268626872688268926902691269226932694269526962697269826992700270127022703270427052706270727082709271027112712271327142715271627172718271927202721272227232724272527262727272827292730273127322733273427352736273727382739274027412742274327442745274627472748274927502751275227532754275527562757275827592760276127622763276427652766276727682769277027712772277327742775277627772778277927802781278227832784278527862787278827892790279127922793279427952796279727982799280028012802280328042805280628072808280928102811281228132814281528162817281828192820282128222823282428252826282728282829283028312832283328342835283628372838283928402841284228432844284528462847284828492850285128522853285428552856285728582859286028612862286328642865286628672868286928702871287228732874287528762877287828792880288128822883288428852886288728882889289028912892289328942895289628972898289929002901290229032904290529062907290829092910291129122913291429152916291729182919292029212922292329242925292629272928292929302931293229332934293529362937293829392940294129422943294429452946294729482949295029512952295329542955295629572958295929602961296229632964296529662967296829692970297129722973297429752976297729782979298029812982298329842985298629872988298929902991299229932994299529962997299829993000300130023003300430053006300730083009301030113012301330143015301630173018301930203021302230233024302530263027302830293030303130323033303430353036303730383039304030413042304330443045304630473048304930503051305230533054305530563057305830593060306130623063306430653066306730683069307030713072307330743075307630773078307930803081308230833084308530863087308830893090309130923093309430953096309730983099310031013102310331043105310631073108310931103111311231133114311531163117311831193120312131223123312431253126312731283129313031313132313331343135313631373138313931403141314231433144314531463147314831493150315131523153315431553156315731583159316031613162316331643165316631673168316931703171317231733174
							<html>
<head>
<meta http-equiv='content-type' content='text/html; charset=utf-8'>
<meta name='description' content='Generated by TinTin++ 2.01.92b - http://tintin.sourceforge.net'>
<style type='text/css'>
{
	font-family: Courier;
	font-size: 10pt;
}
a:link {color: cyan;} a:visited {color: green;} a:hover {color: white;} a:active {color:purple;}
.d30{ color: #000; } .l30{ color: #555; } .b40{ background-color: #000; } .b50{ background-color: #555 }
.d31{ color: #B00; } .l31{ color: #F55; } .b41{ background-color: #B00; } .b51{ background-color: #F55 }
.d32{ color: #0B0; } .l32{ color: #5F5; } .b42{ background-color: #0B0; } .b52{ background-color: #5F5 }
.d33{ color: #BB0; } .l33{ color: #FF5; } .b43{ background-color: #BB0; } .b53{ background-color: #FF5 }
.d34{ color: #00B; } .l34{ color: #55F; } .b44{ background-color: #00B; } .b54{ background-color: #55F }
.d35{ color: #B0B; } .l35{ color: #F5F; } .b45{ background-color: #B0B; } .b55{ background-color: #F5F }
.d36{ color: #0BB; } .l36{ color: #5FF; } .b46{ background-color: #0BB; } .b56{ background-color: #5FF }
.d37{ color: #BBB; } .l37{ color: #FFF; } .b47{ background-color: #BBB; } .b57{ background-color: #FFF }
.d38{ color: #FFF; } .l38{ color: #FFF; } .b48{ background-color: #000; } .b58{ background-color: #000 }
.d39{ color: #FFF; } .l39{ color: #FFF; } .b49{ background-color: #000; } .b59{ background-color: #000 }
</style>
<body bgcolor='#000000'>
</head>
<pre>
<span class='b49'><span class='d39'>
     <a href='#ACTION'>         ACTION</a>     <a href='#ALIAS'>          ALIAS</a>     <a href='#ALL'>            ALL</a>     <a href='#BELL'>           BELL</a>
     <a href='#BREAK'>          BREAK</a>     <a href='#BUFFER'>         BUFFER</a>     <a href='#BUTTON'>         BUTTON</a>     <a href='#CASE'>           CASE</a>
     <a href='#CHARACTERS'>     CHARACTERS</a>     <a href='#CHAT'>           CHAT</a>     <a href='#CLASS'>          CLASS</a>     <a href='#COLORS'>         COLORS</a>
     <a href='#COMMANDS'>       COMMANDS</a>     <a href='#COORDINATES'>    COORDINATES</a>     <a href='#CONFIG'>         CONFIG</a>     <a href='#CONTINUE'>       CONTINUE</a>
     <a href='#CR'>             CR</a>     <a href='#CURSOR'>         CURSOR</a>     <a href='#DAEMON'>         DAEMON</a>     <a href='#DEBUG'>          DEBUG</a>
     <a href='#DEFAULT'>        DEFAULT</a>     <a href='#DELAY'>          DELAY</a>     <a href='#DRAW'>           DRAW</a>     <a href='#ECHO'>           ECHO</a>
     <a href='#ELSE'>           ELSE</a>     <a href='#ELSEIF'>         ELSEIF</a>     <a href='#END'>            END</a>     <a href='#ESCAPE CODES'>   ESCAPE CODES</a>
     <a href='#EVENT'>          EVENT</a>     <a href='#FORALL'>         FORALL</a>     <a href='#FOREACH'>        FOREACH</a>     <a href='#FORMAT'>         FORMAT</a>
     <a href='#FUNCTION'>       FUNCTION</a>     <a href='#GAG'>            GAG</a>     <a href='#GREETING'>       GREETING</a>     <a href='#GREP'>           GREP</a>
     <a href='#HELP'>           HELP</a>     <a href='#HIGHLIGHT'>      HIGHLIGHT</a>     <a href='#HISTORY'>        HISTORY</a>     <a href='#IF'>             IF</a>
     <a href='#IGNORE'>         IGNORE</a>     <a href='#INDEX'>          INDEX</a>     <a href='#INFO'>           INFO</a>     <a href='#KEYPAD'>         KEYPAD</a>
     <a href='#KILL'>           KILL</a>     <a href='#LINE'>           LINE</a>     <a href='#LIST'>           LIST</a>     <a href='#LOCAL'>          LOCAL</a>
     <a href='#LOG'>            LOG</a>     <a href='#LOOP'>           LOOP</a>     <a href='#MACRO'>          MACRO</a>     <a href='#MAP'>            MAP</a>
     <a href='#MATH'>           MATH</a>     <a href='#MATHEMATICS'>    MATHEMATICS</a>     <a href='#MESSAGE'>        MESSAGE</a>     <a href='#MSDP'>           MSDP</a>
     <a href='#NOP'>            NOP</a>     <a href='#PARSE'>          PARSE</a>     <a href='#PATH'>           PATH</a>     <a href='#PATHDIR'>        PATHDIR</a>
     <a href='#PCRE'>           PCRE</a>     <a href='#PORT'>           PORT</a>     <a href='#PROMPT'>         PROMPT</a>     <a href='#READ'>           READ</a>
     <a href='#REGEXP'>         REGEXP</a>     <a href='#REPEAT'>         REPEAT</a>     <a href='#REPLACE'>        REPLACE</a>     <a href='#RETURN'>         RETURN</a>
     <a href='#RUN'>            RUN</a>     <a href='#SCAN'>           SCAN</a>     <a href='#SCREEN'>         SCREEN</a>     <a href='#SCREEN READER'>  SCREEN READER</a>
     <a href='#SCRIPT'>         SCRIPT</a>     <a href='#SEND'>           SEND</a>     <a href='#SESSION'>        SESSION</a>     <a href='#SESSIONNAME'>    SESSIONNAME</a>
     <a href='#SHOWME'>         SHOWME</a>     <a href='#SNOOP'>          SNOOP</a>     <a href='#SPEEDWALK'>      SPEEDWALK</a>     <a href='#SPLIT'>          SPLIT</a>
     <a href='#SSL'>            SSL</a>     <a href='#STATEMENTS'>     STATEMENTS</a>     <a href='#SUBSTITUTE'>     SUBSTITUTE</a>     <a href='#SUSPEND'>        SUSPEND</a>
     <a href='#SWITCH'>         SWITCH</a>     <a href='#SYSTEM'>         SYSTEM</a>     <a href='#TAB'>            TAB</a>     <a href='#TEXTIN'>         TEXTIN</a>
     <a href='#TICKER'>         TICKER</a>     <a href='#TIME'>           TIME</a>     <a href='#VARIABLE'>       VARIABLE</a>     <a href='#WHILE'>          WHILE</a>
     <a href='#WRITE'>          WRITE</a>     <a href='#ZAP'>            ZAP</a>


<a name='ACTION'></a>

</span><span class='l32'>         ACTION

</span><span class='l37'>Command</span><span class='d37'>: #action </span><span class='l37'>{</span><span class='d37'>message</span><span class='l37'>} {</span><span class='d37'>commands</span><span class='l37'>} {</span><span class='d37'>priority</span><span class='l37'>}</span><span class='d37'>

         The #action command can be used to respond with one or several
         commands to a specific message send by the server. The %1-%99
         variables are substituted from the message and can be used in the
         command part of the action.

         The priority part is optional and determines the priority of the
         action, it defaults to 5.

         If the message starts with a ~ color codes must be matched. You can
         enable #config {convert meta} on to display meta characters.

         For more information on pattern matching see the section on PCRE.

</span><span class='l37'>Example</span><span class='d37'>: #action {%1 tells you '%2'} {tell %1 I'm afk.}

         Actions can be triggered by the showme command and certain system
         messages.

         Actions can be triggered by the #showme command. If you don't want a
         #showme to get triggered use: #line ignore #showme {text}

         Actions are ordered alphabetically and only one action can trigger at
         a time. To change the order you can assign a priority, which defaults
         to 5, with a lower number indicating a higher priority. The priority
         can be a floating point number.

         To remove action with %* as the message, use #unaction {%%*} or
         #unaction {%*}. Alternatively you could wrap the action inside a
         class, and kill that class when you no longer need the action.

</span><span class='l37'>Comment</span><span class='d37'>: You can remove an action with the #unaction command.

</span><span class='l37'>Related</span><span class='d37'>: pcre, gag, highlight, prompt and substitute.
<a name='ALIAS'></a>

</span><span class='l32'>         ALIAS

</span><span class='l37'>Command</span><span class='d37'>: #alias </span><span class='l37'>{</span><span class='d37'>name</span><span class='l37'>} {</span><span class='d37'>commands</span><span class='l37'>}</span><span class='d37'>

         The #alias command can be used to shorten up long or oftenly used
         commands. The %1-99 variables are substituted from the arguments when
         using an alias and represent the 1st till 99th word which can be used
         in the commands part of the alias. If %0 is used it will contain all
         arguments. The priority part is optional and determines the priority
         of the alias, it defaults to 5.

</span><span class='l37'>Example</span><span class='d37'>: #alias {k} {kill %1;kick}

         Typing 'k orc' would result in attacking the orc followed by a kick.

         You can create multi-word aliases by using variables in the name
         section.

</span><span class='l37'>Example</span><span class='d37'>: #alias {k %1 with %2} {draw %2;attack %1;slash %1 with %2;
           kick at %2;strike %1 with %2}

         Using the above alias you could type k blue smurf with battle axe

         To have an alias that matches all user input, use %* as the name.

</span><span class='l37'>Example</span><span class='d37'>: #alias {%*} {#showme You wrote: %0}

         Aliases are ordered alphabetically and only one alias can trigger at
         a time. To change the order you can assign a priority, which defaults
         to 5, with a lower number indicating a higher priority. The priority
         can be a floating point number.

         To remove an alias with %* as the name, use #unalias {%%*} or #unalias
         {%*}. Alternatively you can wrap the alias inside a class, and kill
         that class when you no longer need the alias.

         For more information on pattern matching see the section on PCRE.

</span><span class='l37'>Comment</span><span class='d37'>: You can remove an alias with the #unalias command.

</span><span class='l37'>Related</span><span class='d37'>: cursor, history, keypad, macro, speedwalk and tab.
<a name='ALL'></a>

</span><span class='l32'>         ALL

</span><span class='l37'>Command</span><span class='d37'>: #all </span><span class='l37'>{</span><span class='d37'>string</span><span class='l37'>}</span><span class='d37'>

         If you have multiple sessions in one terminal you can use #all to
         execute the command with all sessions, excluding the startup session.

</span><span class='l37'>Example</span><span class='d37'>: #all quit

         Sends 'quit' to all sessions.

</span><span class='l37'>Related</span><span class='d37'>: port, run, session, sessionname, snoop, ssl and zap.
<a name='BELL'></a>

</span><span class='l32'>         BELL

</span><span class='l37'>Command</span><span class='d37'>: #bell </span><span class='l37'>{</span><span class='d37'>flash</span><span class='l37'>|</span><span class='d37'>focus</span><span class='l37'>|</span><span class='d37'>margin</span><span class='l37'>|</span><span class='d37'>ring</span><span class='l37'>|</span><span class='d37'>volume</span><span class='l37'>} {</span><span class='d37'>argument</span><span class='l37'>}</span><span class='d37'>

         The #bell command without an argument will ring the terminal bell.

</span><span class='l37'>Example</span><span class='d37'>: #action {Bubba tells you} {#bell}

         If you aren't watching the screen this could be useful if you don't
         want to miss out on a conversation with Bubba. Alternatively you can
         use #system to play a sound file.

         Some terminals will allow you to use VT100 Operating System Commands
         to change the terminal's bell behavior which can be used to flash the
         taskbar icon and or focus the window on receival of a bell.

</span><span class='l37'>Example</span><span class='d37'>: #action {Bubba tells you} {#screen save title;#screen set title Tell!;
           #bell ring;#delay 10 #screen load title}

         The above example will save your window title, change the title to
         'Tell!', ring the bell, next reset the window title after 10 seconds.

         It's possible to set the terminal to pop to the foreground upon
         ringing of the alarm bell.

</span><span class='l37'>Example</span><span class='d37'>: #bell focus on;#bell ring;#bell focus off

         It's possible to adjust the alarm bell volume on some terminals.

</span><span class='l37'>Example</span><span class='d37'>: #loop {1} {8} {cnt} {#line substitute variables
           #delay {&dollar;cnt} #showme {Volume &dollar;cnt: #bell volume &dollar;cnt;#bell}

</span><span class='l37'>Related</span><span class='d37'>: screen
<a name='BREAK'></a>

</span><span class='l32'>         BREAK

</span><span class='l37'>Command</span><span class='d37'>: #break

         The break command can be used inside the #foreach, #loop, #parse,
         #while and #switch statements. When #break is found, tintin will stop
         executing the statement it is currently in and move on to the next.

</span><span class='l37'>Example</span><span class='d37'>: #while {1} {#math cnt &dollar;cnt + 1;#if {&dollar;cnt == 20} {#break}}

</span><span class='l37'>Related</span><span class='d37'>: statements
<a name='BUFFER'></a>

</span><span class='l32'>         BUFFER

</span><span class='l37'>Command</span><span class='d37'>: #buffer </span><span class='l37'>{</span><span class='d37'>home</span><span class='l37'>|</span><span class='d37'>up</span><span class='l37'>|</span><span class='d37'>down</span><span class='l37'>|</span><span class='d37'>end</span><span class='l37'>|</span><span class='d37'>lock</span><span class='l37'>|</span><span class='d37'>find</span><span class='l37'>|</span><span class='d37'>get</span><span class='l37'>|</span><span class='d37'>clear</span><span class='l37'>}</span><span class='d37'>

         The buffer command has various options to manipulate your scrollback
         buffer.

         </span><span class='l37'>#buffer {home}
</span><span class='d37'>
         Moves you to the top of your scrollback buffer and displays the page.
         Enables scroll lock mode. Most useful when used in a #macro.

         </span><span class='l37'>#buffer {up} [lines]
</span><span class='d37'>
         Moves your scrollback buffer up one page and displays the page.
         Enables scroll lock mode. Most useful when used in a #macro. You
         can use #buffer {up} {1} to move the scrollback buffer up 1 line.

         </span><span class='l37'>#buffer {down} [lines]
</span><span class='d37'>
         Moves your scrollback buffer down one page and displays the page.
         Enables scroll lock mode unless at the end. Most useful when used in
         a #macro.

         </span><span class='l37'>#buffer {end}
</span><span class='d37'>
         Moves you to the end of your scrollback buffer and displays the page.
         Disables scroll lock mode. Most useful when used in a #macro.

         </span><span class='l37'>#buffer {find} {[number]} {&lt;string&gt;}
</span><span class='d37'>
         Moves the buffer to the given string which can contain a regular
         expression. Optionally you can provide the number of matches to skip,
         allowing you to jump further back in the buffer.

         </span><span class='l37'>#buffer {get} {&lt;variable&gt;} {&lt;lower bound&gt;} {[upper bound]}
</span><span class='d37'>
         Allows you to store one or several lines from your scrollback buffer
         (including color codes) into a variable. The lower and upper bound
         must be between 1 and the size of the buffer. If the upper bound is
         omitted the given line is stored as a standard variable. If an upper
         bound is given the lines between the two bounds are stored as a list.

         </span><span class='l37'>#buffer {lock} {on|off}
</span><span class='d37'>
         Toggles the lock on the scrollback buffer. When locked, newly incoming
         text won't be displayed, any command will disable the lock, though
         several buffer commands will re-enable the lock. When unlocking it'll
         move you to the end of your scrollback buffer and display the page.

         </span><span class='l37'>#buffer {write} {&lt;filename&gt;}
</span><span class='d37'>
         Writes the scrollback buffer to the given file.

</span><span class='l37'>Example</span><span class='d37'>: #macro {&bsol;e[F} {#buffer end}

</span><span class='l37'>Related</span><span class='d37'>: echo, grep, macro, showme and screen.
<a name='BUTTON'></a>

</span><span class='l32'>         BUTTON

</span><span class='l37'>Command</span><span class='d37'>: #button </span><span class='l37'>{</span><span class='d37'>square</span><span class='l37'>} {</span><span class='d37'>commands</span><span class='l37'>} {</span><span class='d37'>priority</span><span class='l37'>}</span><span class='d37'>

         The #button command can be used to respond with one or several
         commands to a mouse click received within the specified square.
         The click coordinates are stored in %0-%3 and can be used in the
         command part of the button.

         The square part should exists of two coordinates defining the
         upper left and bottom right corner using row, col, row, col syntax.
         The square arguments should be separated by spaces, semi-colons or
         braces.

         By default the button is set to respond to a mouse button press, to
         respond to other button presses you must add a 5th argument to the
         square that defines the button press type. You can enable #info
         button on to see button events and their type as they happen.

         The priority part is optional and determines the priority of the
         button, it defaults to 5.

         You must enable #config {mouse tracking} on for buttons to work.

         This command draws no visible button, you'll have to do so separately
         if needed.

</span><span class='l37'>Example</span><span class='d37'>: #button {1;1;2;2} {#showme You clicked the upper left corner.}

         Buttons are ordered alphabetically and only one button can trigger at
         a time. To change the order you can assign a priority, which defaults
         to 5, with a lower number indicating a higher priority. The priority
         can be a floating point number.

</span><span class='l37'>Comment</span><span class='d37'>: To see button clicks trigger use #info button on.

</span><span class='l37'>Comment</span><span class='d37'>: You can remove a button with the #unbutton command.

</span><span class='l37'>Related</span><span class='d37'>: delay, event and ticker.
<a name='CASE'></a>

</span><span class='l32'>         CASE

</span><span class='l37'>Command</span><span class='d37'>: #case </span><span class='l37'>{</span><span class='d37'>conditional</span><span class='l37'>} {</span><span class='d37'>arguments</span><span class='l37'>}</span><span class='d37'>

         The case command must be used within the #switch command. When the
         conditional argument of the case command matches the conditional
         argument of the switch command the body of the case is executed.

         When comparing strings both the switch and case arguments must be
         surrounded in quotes.

</span><span class='l37'>Example</span><span class='d37'>:

         #function {reverse_direction}
         {
             #switch {&quot;%1&quot;}
             {
                 #case {&quot;north&quot;} {#return south};
                 #case {&quot;east&quot;}  {#return west};
                 #case {&quot;south&quot;} {#return north};
                 #case {&quot;west&quot;}  {#return east};
                 #case {&quot;up&quot;}    {#return down};
                 #case {&quot;down&quot;}  {#return up}
             }
         }

         This function returns the reverse direction. @reverse_direction{north}
         would return south.

</span><span class='l37'>Related</span><span class='d37'>: default, statements and switch.
<a name='CHARACTERS'></a>

</span><span class='l32'>         CHARACTERS

</span><span class='d37'>
         The following special characters are defined:

#        The hashtag is the default character for starting a command and is
         subsequently known as the command character or tintin character.
         When loading a command file the command character is set to the
         first character in the file. The character can also be redefined
         using #config.

;        The semi-colon is used as the command separator and can be used to
         separate two commands. Multiple commands can be strung together as
         well. Trailing semi-colons are ignored when reading a script file
         as this is a common error.

{ }      Curly brackets aka braces are used for seperating multi word command
         arguments, nesting commands, and nesting variables. Braces cannot
         easily be escaped and must always be used in pairs.

&quot; &quot;      Quote characters are used for strings in the #math, #if, #switch,
         and #case commands. It is however suggested to use an extra
         set of braces { } to define strings.

!        The exclamation sign is used to repeat commands, see #help history.
         The character can be redefined using #config.

&bsol;        An input line starting with a backslash is send verbatim if you are
         connected to a server. This character can be configured with
         #config.

</span><span class='l37'>Related</span><span class='d37'>: colors, escape, mathematics and pcre.
<a name='CHAT'></a>

</span><span class='l32'>         CHAT

</span><span class='l37'>Command</span><span class='d37'>: #chat </span><span class='l37'>{</span><span class='d37'>option</span><span class='l37'>} {</span><span class='d37'>argument</span><span class='l37'>}</span><span class='d37'>

         #chat {init}       {port}             Initilizes a chat port.
         #chat {name}       {name}             Sets your chat name.
         #chat {message}    {buddy|all} {text} Sends a chat message

         #chat {accept}     {buddy} {boost}    Accept a file transfer
         #chat {call}       {address} {port}   Connect to a buddy
         #chat {cancel}     {buddy}            Cancel a file transfer
         #chat {color}      {color names}      Set the default color
         #chat {decline}    {buddy}            Decline a file transfer
         #chat {dnd}                           Decline new connections
         #chat {download}   {directory}        Set your download directory
         #chat {emote}      {buddy|all} {text} Send an emote message
         #chat {forward}    {buddy}            Forward all chat messages
         #chat {forwardall} {buddy}            Forward all session output
         #chat {filestat}   {buddy}            Show file transfer data
         #chat {group}      {buddy} {name}     Assign a chat group
         #chat {ignore}     {buddy}            Ignores someone
         #chat {info}                          Displays your info
         #chat {ip}         {address}          Changes your IP address
         #chat {paste}      {buddy|all} {text} Pastes a block of text
         #chat {peek}       {buddy}            Show one's public connections
         #chat {ping}       {buddy}            Display response time
         #chat {private}    {buddy|all}        Make a connection private
         #chat {public}     {buddy|all}        Make a connection public
         #chat {reply}      {text}             Reply to last private message
         #chat {request}    {buddy}            Request one's public connections
         #chat {send}       {buddy|all} {text} Sends a raw data string
         #chat {sendfile}   {buddy} {filename} Start a file transfer
         #chat {serve}      {buddy}            Forward all public chat messages
         #chat {uninitialize}                  Uninitialize the chat port.
         #chat {who}                           Show all connections
         #chat {zap}        {buddy}            Close a connection

</span><span class='l37'>Related</span><span class='d37'>: port
<a name='CLASS'></a>

</span><span class='l32'>         CLASS

</span><span class='l37'>Command</span><span class='d37'>: #class </span><span class='l37'>{</span><span class='d37'>name</span><span class='l37'>} {</span><span class='d37'>open</span><span class='l37'>|</span><span class='d37'>close</span><span class='l37'>|</span><span class='d37'>list</span><span class='l37'>|</span><span class='d37'>read</span><span class='l37'>|</span><span class='d37'>size</span><span class='l37'>|</span><span class='d37'>write</span><span class='l37'>|</span><span class='d37'>kill</span><span class='l37'>} {</span><span class='d37'>arg</span><span class='l37'>}</span><span class='d37'>

         The {open} option will open a class, closing a previously opened
         class. All triggers added afterwards are assigned to this class.
         The {close} option will close the given class.
         The {list} option will show the given list of the class.
         The {read} option will open the class, read, and close afterwards.
         The {size} option will store the size of the class in a variable.
         The {write} option will write all triggers of the given class to file.
         The {kill} option will delete all triggers of the given class.

         Keep in mind that the kill and read option are very fast allowing
         them to be used to enable and disable classes.

</span><span class='l37'>Example</span><span class='d37'>: #class extra kill;#class extra read extra.tin
         Deletes all triggers of 'extra' class if any. Read 'extra.tin' file,
         all triggers loaded will be assigned to the fresh new 'extra' class.

</span><span class='l37'>Related</span><span class='d37'>: config, debug, ignore, info, kill, line and message.
<a name='COLORS'></a>

</span><span class='l32'>         COLORS

</span><span class='l37'>Syntax</span><span class='d37'>:  &lt;xyz&gt;  with x, y, z being parameters

         Parameter 'x': VT100 code

         0 - Reset all colors and codes to default
         1 - Bold
         2 - Dim
         4 - Underscore
         5 - Blink
         7 - Reverse
         8 - Skip (use previous code)

         Parameter 'y':  Foreground color
         Parameter 'z':  Background color

         0 - Black                5 - Magenta
         1 - Red                  6 - Cyan
         2 - Green                7 - White
         3 - Yellow               8 - Skip
         4 - Blue                 9 - Default

         For xterm 256 colors support use &lt;aaa&gt; to &lt;fff&gt; for RGB foreground
         colors and &lt;AAA&gt; to &lt;FFF&gt; for RGB background colors. For the grayscale
         foreground colors use &lt;g00&gt; to &lt;g23&gt;, for grayscale background colors
         use &lt;G00&gt; to &lt;G23&gt;.

         The tertiary colors are as follows:

         &lt;acf&gt; - Azure            &lt;afc&gt; - Jade
         &lt;caf&gt; - Violet           &lt;cfa&gt; - Lime
         &lt;fac&gt; - Pink             &lt;fca&gt; - Orange

</span><span class='l37'>Example</span><span class='d37'>: #showme &lt;acf&gt;Azure    &lt;afc&gt;Jade     &lt;caf&gt;Violet
</span><span class='l37'>Example</span><span class='d37'>: #showme &lt;cfa&gt;Lime     &lt;fac&gt;Pink     &lt;fca&gt;Orange

         For 12 bit truecolor use &lt;F000&gt; to &lt;FFFF&gt; for foreground colors and
         &lt;B000&gt; to &lt;BFFF&gt; for background colors.

         For 24 bit truecolor use &lt;F000000&gt; to &lt;FFFFFFF&gt; for foreground
         colors and &lt;B000000&gt; to &lt;BFFFFFF&gt; for background colors.

         If the color code exceeds your configured color mode it will be
         downgraded to the closest match.

</span><span class='l37'>Related</span><span class='d37'>: characters, coordinates, escape, mathematics and pcre.
<a name='COMMANDS'></a>

</span><span class='l32'>         COMMANDS

</span><span class='l37'>Command</span><span class='d37'>: #commands </span><span class='l37'>{</span><span class='d37'>regex</span><span class='l37'>}
</span><span class='d37'>
         Shows all commands or all commands matching the given search
         string.

</span><span class='l37'>Related</span><span class='d37'>: help, info and statements.
<a name='COORDINATES'></a>

</span><span class='l32'>         COORDINATES

</span><span class='d37'>
         When the 0,0 coordinate is in the upper left corner TinTin++ uses
         a y,x / rows,cols notation. When the 0,0 coordinate is in the
         bottom left corner tintin uses a x,y / cols/rows notation.

         When a square is defined this is done by specifying the upper left
         and bottom right corner of the square using four coordinates.

         The vast majority of tintin commands use row,col notation.

</span><span class='l37'>Related</span><span class='d37'>: characters, colors, escape, mathematics and pcre.
<a name='CONFIG'></a>

</span><span class='l32'>         CONFIG

</span><span class='l37'>Command</span><span class='d37'>: #config </span><span class='l37'>{</span><span class='d37'>option</span><span class='l37'>} {</span><span class='d37'>argument</span><span class='l37'>}</span><span class='d37'>

         This allows you to configure various settings, the settings can be
         written to file with the #write or #writesession command.

         If you configure the global session (the one you see as you start up
         tintin) all sessions started will inherite these settings.

         It's advised to make a configuration file to read on startup if you
         do not like the default settings.

         Config options which aren't listed by default:

         #CONFIG {BUFFER SIZE}    {SIZE} Set the scrollback buffer size.
         #CONFIG {CHILD LOCK}   {ON|OFF} Enable or disable command input.
         #CONFIG {CONVERT META} {ON|OFF} Shows color codes and key bindings.
         #CONFIG {DEBUG TELNET} {ON|OFF} Shows telnet negotiations y/n.
         #CONFIG {LOG LEVEL}  {LOW|HIGH} LOW logs mud output before triggers.
         #CONFIG {INHERITANCE}  {ON|OFF} Session trigger inheritance y/n.
         #CONFIG {MCCP}         {ON|OFF} Enable or disable MCCP support.
         #CONFIG {PID}          {NUMBER} Set the PID of the master process.

</span><span class='l37'>Related</span><span class='d37'>: class and line.
<a name='CONTINUE'></a>

</span><span class='l32'>         CONTINUE

</span><span class='l37'>Command</span><span class='d37'>: #continue

         The continue command can be used inside the #FOREACH, #LOOP, #PARSE,
         #WHILE and #SWITCH commands. When #CONTINUE is found, tintin will go
         to the end of the command and proceed as normal, which may be to
         reiterate the command.

</span><span class='l37'>Example</span><span class='d37'>: #loop 1 10 cnt {#if {&dollar;cnt % 2 == 0} {#continue} {say &dollar;cnt}}

</span><span class='l37'>Related</span><span class='d37'>: break, foreach, list, loop, parse, repeat, return and while.
<a name='CR'></a>

</span><span class='l32'>         CR

</span><span class='l37'>Command</span><span class='d37'>: #cr

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

         This command is obsolete as you can accomplish the same using #send
         without an argument or #send {}.

</span><span class='l37'>Related</span><span class='d37'>: forall
<a name='CURSOR'></a>

</span><span class='l32'>         CURSOR

</span><span class='l37'>Command</span><span class='d37'>: #cursor </span><span class='l37'>{</span><span class='d37'>option</span><span class='l37'>} {</span><span class='d37'>argument</span><span class='l37'>}</span><span class='d37'>

         Typing #cursor without an option will show all available cursor
         options, their default binding, and an explanation of their function.

         The cursor command's primarly goal is adding customizable input editing
         with macros. Subsequently many cursor commands only work properly when
         used within a macro or event.

</span><span class='l37'>Related</span><span class='d37'>: alias, history, keypad, macro, speedwalk and tab.
<a name='DAEMON'></a>

</span><span class='l32'>         DAEMON

</span><span class='l37'>Command</span><span class='d37'>: #daemon </span><span class='l37'>{</span><span class='d37'>attach</span><span class='l37'>|</span><span class='d37'>detach</span><span class='l37'>|</span><span class='d37'>kill</span><span class='l37'>|</span><span class='d37'>list</span><span class='l37'>} [</span><span class='d37'>name</span><span class='l37'>]

         </span><span class='d37'>#daemon provides functionality similar to that of the screen and tmux
         utilities.

         </span><span class='l37'>#daemon attach [name]
         </span><span class='d37'>  The attach option will try to find a daemonized tintin instance and
           take over control. The name argument is optional.

         </span><span class='l37'>#daemon detach [name]
         </span><span class='d37'>  The detach option will daemonize tintin, turning it into a background
           process. The name argument is optional and is useful if you have
           several daemonized tt++ instances running so you can keep them apart.

         </span><span class='l37'>#daemon kill [name]
         </span><span class='d37'>  Kills all daemons or daemons with matching name.

         </span><span class='l37'>#daemon list [name]
         </span><span class='d37'>  List all daemons or daemons with matching name.

</span><span class='l37'>Related</span><span class='d37'>: script, system and run.
<a name='DEBUG'></a>

</span><span class='l32'>         DEBUG

</span><span class='l37'>Command</span><span class='d37'>: #debug </span><span class='l37'>{</span><span class='d37'>listname</span><span class='l37'>} {</span><span class='d37'>on</span><span class='l37'>|</span><span class='d37'>off</span><span class='l37'>|</span><span class='d37'>log</span><span class='l37'>}</span><span class='d37'>

         Toggles a list on or off. With no argument it shows your current
         settings, as well as the list names that you can debug.

         If you for example set ACTIONS to ON you will get debug information
         whenever an action is triggered.

         #debug {listname} {log} will silently write debugging information to
         the log file, you must be logging in order for this to work.

         Not every list has debug support yet.

</span><span class='l37'>Related</span><span class='d37'>: class, ignore, info, kill and message.
<a name='DEFAULT'></a>

</span><span class='l32'>         DEFAULT

</span><span class='l37'>Command</span><span class='d37'>: #default </span><span class='l37'>{</span><span class='d37'>commands</span><span class='l37'>}</span><span class='d37'>

         The default command can only be used within the switch command. When
         the conditional argument of non of the case commands matches the switch
         command's conditional statement the default command is executed.

</span><span class='l37'>Related</span><span class='d37'>: case, default, else, elseif, if, switch and regex.
<a name='DELAY'></a>

</span><span class='l32'>         DELAY

</span><span class='l37'>Command</span><span class='d37'>: #delay </span><span class='l37'>{</span><span class='d37'>seconds</span><span class='l37'>} {</span><span class='d37'>command</span><span class='l37'>}</span><span class='d37'>
</span><span class='l37'>Command</span><span class='d37'>: #delay </span><span class='l37'>{</span><span class='d37'>name</span><span class='l37'>} {</span><span class='d37'>command</span><span class='l37'>} {</span><span class='d37'>seconds</span><span class='l37'>}</span><span class='d37'>

         Delay allows you to have tintin wait the given amount of seconds
         before executing the given command. tintin won't wait before
         executing following input commands if any.

         Floating point precision for miliseconds is possible.

</span><span class='l37'>Example</span><span class='d37'>: #showme first;#delay {1} {#showme last}
         This will print 'first', and 'last' around one second later.

</span><span class='l37'>Comment</span><span class='d37'>: If you want to remove a delay with the #undelay command you can add
         a name as the first argument, be aware this changes the syntax. If
         the name is a number keep in mind that delays with the same numeric
         name will not be overwritten

</span><span class='l37'>Related</span><span class='d37'>: event and ticker.
<a name='DRAW'></a>

</span><span class='l32'>         DRAW

</span><span class='l37'>Command</span><span class='d37'>: #draw </span><span class='l37'>[</span><span class='d37'>color</span><span class='l37'>] [</span><span class='d37'>options</span><span class='l37'>] &lt;</span><span class='d37'>type</span><span class='l37'>&gt; &lt;</span><span class='d37'>square</span><span class='l37'>&gt; {</span><span class='d37'>text</span><span class='l37'>}
</span><span class='d37'>
         The draw commands allows you to draw various types of lines and shapes
         on the screen. Common options and types with a brief description are
         provided when you type #draw without an argument.

         The square arguments should exists of two coordinates defining the
         upper left and bottom right corner using row, col, row, col syntax.


       You can prefix the option with a color code or color name to color the
         lines and shapes.

         You can further prefix the option as following:

         ASCII      will draw in ASCII mode.
         BLANKED    will blank the lines and corners.
         BOTTOM     will draw on the bottom side if possible.
         BUMPED     will precede the draw with an enter.
         CIRCLED    will circle the corners.
         CONVERT    will draw text with meta conversion.
         CORNERED   will draw lines with corners if possible.
         CROSSED    will cross the corners.
         HORIZONTAL will draw horizontal if possible.
         JEWELED    will diamond the corners.
         LEFT       will draw on the left side if possible.
         PRUNED     will prune the corners.
         RIGHT      will draw on the right side if possible.
         ROUNDED    will round the corners.
         TEED       will tee the corners.
         TOP        will draw on the top side if possible.
         TUBED      will draw tubes instead of lines.
         UNICODE    will draw in unicode mode.
         VERTICAL   will draw vertical if possible.

         The following types are available.

         BOX        will draw a box.
         LINE       will draw a line.
         SIDE       will draw one or more sides of a box.
         TILE       will draw a tile

         All draw types take an optional text argument as long as a valid
         square with enough space has been defined. Text is automatically
         word wrapped.

</span><span class='l37'>Example</span><span class='d37'>: #draw {box} 1 1 3 20 {Hello world!}

</span><span class='l37'>Related</span><span class='d37'>: buffer, echo, grep and showme.
<a name='ECHO'></a>

</span><span class='l32'>         ECHO

</span><span class='l37'>Command</span><span class='d37'>: #echo </span><span class='l37'>{</span><span class='d37'>format</span><span class='l37'>} {</span><span class='d37'>argument1</span><span class='l37'>} {</span><span class='d37'>argument2</span><span class='l37'>} {</span><span class='d37'>etc</span><span class='l37'>}</span><span class='d37'>

         Echo command displays text on the screen with formatting options. See
         the help file for the format command for more informations.

         The echo command does not trigger actions.

         As with the #showme command you can split the {format} argument up into
         two braced arguments, in which case the 2nd argument is the row number.

</span><span class='l37'>Example</span><span class='d37'>: #echo {The current date is %t.} {%Y-%m-%d %H:%M:%S}
         #echo {[%38s][%-38s]} {Hello World} {Hello World}
         #echo {{this is %s on the top row} {-1}} {printed}

</span><span class='l37'>Related</span><span class='d37'>: buffer, grep and showme.
<a name='ELSE'></a>

</span><span class='l32'>         ELSE

</span><span class='l37'>Command</span><span class='d37'>: #else </span><span class='l37'>{</span><span class='d37'>commands</span><span class='l37'>}</span><span class='d37'>

         The else statement should follow an #IF or #ELSEIF statement and is
         only called if the proceeding #IF or #ELSEIF is false.

</span><span class='l37'>Example</span><span class='d37'>: #if {1d2 == 1} {smile};#else {grin}

</span><span class='l37'>Related</span><span class='d37'>: case, default, elseif, if, switch and regex.
<a name='ELSEIF'></a>

</span><span class='l32'>         ELSEIF

</span><span class='l37'>Command</span><span class='d37'>: #elseif </span><span class='l37'>{</span><span class='d37'>conditional</span><span class='l37'>} {</span><span class='d37'>commands</span><span class='l37'>}</span><span class='d37'>

         The elseif statement should follow an #IF or #ELSEIF statement and is
         only called when the statement is true and the proceeding #IF and
         #ELSEIF statements are false.

</span><span class='l37'>Example</span><span class='d37'>: #if {1d3 == 1} {smirk};#elseif {1d2 == 1} {snicker}

</span><span class='l37'>Related</span><span class='d37'>: case, default, else, if, switch and regex.
<a name='END'></a>

</span><span class='l32'>         END

</span><span class='l37'>Command</span><span class='d37'>: #end {&lt;message&gt;}

         Terminates tintin and return to unix.  On most systems, ctrl-c has
         the same result.

         The message is optional and is printed before tintin exits. When
         using #end {&bsol;} tintin will terminate silently.

</span><span class='l37'>Related</span><span class='d37'>: zap
<a name='ESCAPE CODES'></a>

</span><span class='l32'>         ESCAPE CODES

</span><span class='d37'>         You may use the escape character &bsol; for various special characters.

         &bsol;a    beep the terminal.
         &bsol;c    send a control character, &bsol;ca for ctrl-a.
         &bsol;e    start an escape sequence.
         &bsol;n    send a line feed.
         &bsol;r    send a carriage return.
         &bsol;t    send a horizontal tab.
         &bsol;x    print an 8 bit character using hexadecimal, &bsol;xFF for example.
         &bsol;x7B  send the '{' character.
         &bsol;x7D  send the '}' character.
         &bsol;u    print a 16 bit unicode character, &bsol;uFFFD for example.
         &bsol;U    print a 21 bit unicode character, &bsol;U02AF21 for example.
         &bsol;v    send a vertical tab

         Ending a line with &bsol; will stop tintin from appending a line feed.
         To escape arguments in an alias or action use %%0 %%1 %%2 etc.

</span><span class='l37'>Related</span><span class='d37'>: characters, colors, coordinates, mathematics and pcre.
<a name='EVENT'></a>

</span><span class='l32'>         EVENT

</span><span class='l37'>Command</span><span class='d37'>: #event </span><span class='l37'>{</span><span class='d37'>event type</span><span class='l37'>}</span><span class='d37'>

         Events allow you to create triggers for predetermined client events.

         Use #event without an argument to see a list of possible events with
         a brief description. Use #event %* to see the current list of defined
         events. Use #info {events} {on} to see events get thrown.

         Some events can be prefixed with CATCH to interrupt default behavior.

         CATCH &lt;EVENT&gt;
         CHAT MESSAGE           %0 default %1 plain
         CLASS ACTIVATED        %0 class name
         CLASS DEACTIVATED      %0 class name
         DATE                   %1 month - %3 day   %4 hour : %5 minute
         DAY &lt;DAY&gt;              %3 day of the month
         DOUBLE-CLICKED &lt;VAR&gt;   %0 row %1 col %2 -row %3 -col %4 word %5 line
         END OF PATH
         HOUR                   %4 hour
         IAC &lt;VAR&gt; &lt;VAR&gt;
         IAC SB GMCP &lt;MODULE&gt;   %0 data     %1 raw data
         IAC SB MSSP            %0 variable %1 value
         IAC SB MSDP            %0 variable %1 value
         IAC SB MSDP &lt;VAR&gt;      %1 value
         IAC SB NEW-ENVIRON     %0 variable %1 value
         IAC SB ZMP &lt;VAR&gt;       %0 value
         IAC SB &lt;VAR&gt;           %0 raw text %1 raw data
         LONG-CLICKED &lt;VAR&gt;     %0 row %1 col %2 -row %3 -col %4 word %5 line
         MAP ENTER MAP          %0 new vnum
         MAP ENTER ROOM         %0 new vnum %1 old vnum
         MAP ENTER ROOM &lt;VAR&gt;   %0 new vnum %1 old vnum
         MAP EXIT MAP           %0 old vnum
         MAP EXIT ROOM          %0 old vnum %1 new vnum
         MAP EXIT ROOM &lt;VAR&gt;    %0 old vnum %1 new vnum
         MAP FOLLOW MAP         %0 old vnum %1 new vnum %2 exit name
         MAP UPDATED VTMAP
         MINUTE                 %5 minute
         MONTH                  %1 month
         MOVED &lt;VAR&gt;            %0 row %1 col %2 -row %3 -col %4 word %5 line
         PORT CONNECTION        %0 name %1 ip %2 port
         PORT DISCONNECTION     %0 name %1 ip %2 port
         PORT MESSAGE           %0 data %1 plain data
         PORT LOG MESSAGE       %0 name %1 ip %2 port %3 data %4 plain data
         PORT RECEIVED MESSAGE  %0 name %1 ip %2 port %3 data %4 plain data
         PRESSED &lt;VAR&gt;          %0 row %1 col %2 -row %3 -col %4 word %5 line
         PROGRAM START          %0 startup arguments
         PROGRAM TERMINATION    %0 goodbye message
         READ ERROR             %0 filename %1 error message
         RECEIVED INPUT         %0 raw text
         RECEIVED KEYPRESS      %0 raw text %1 unicode index
         RECEIVED LINE          %0 raw text %1 plain text
         RECEIVED OUTPUT        %0 raw text
         RECEIVED PROMPT        %0 raw text %1 plain text
         RELEASED &lt;VAR&gt;         %0 row %1 col %2 -row %3 -col %4 word %5 line
         SCAN CSV HEADER        %0 all args %1 arg1 %2 arg2 .. %99 arg99
         SCAN CSV LINE          %0 all args %1 arg1 %2 arg3 .. %99 arg99
         SCAN TSV HEADER        %0 all args %1 arg1 %2 arg3 .. %99 arg99
         SCAN TSV LINE          %0 all args %1 arg1 %2 arg3 .. %99 arg99
         SCREEN RESIZE          %0 rows %1 cols %1 height %2 width
         SCREEN SPLIT           %0 top row %1 top col %2 bot row %3 bot col
         SCREEN UNSPLIT         %0 top row %1 top col %2 bot row %3 bot col
         SCROLLED &lt;VAR&gt;         %0 row %1 col %2 -row %3 -col %4 word %5 line
         SECOND                 %6 second
         SEND OUTPUT            %0 raw text %1 size
         SENT OUTPUT            %0 raw text %1 size
         SESSION ACTIVATED      %0 name
         SESSION CONNECTED      %0 name %1 host %2 ip %3 port
         SESSION CREATED        %0 name %1 host %2 ip %3 port
         SESSION DEACTIVATED    %0 name
         SESSION DISCONNECTED   %0 name %1 host %2 ip %3 port
         SESSION TIMED OUT      %0 name %1 host %2 ip %3 port
         SHORT-CLICKED &lt;VAR&gt;    %0 row %1 col %2 -row %3 -col %4 word %5 line
         SYSTEM ERROR           %0 name %1 system msg %2 error %3 error msg
         TIME                   %4 hour : %5 minute : %6 second
         TRIPLE-CLICKED &lt;VAR&gt;   %0 row %1 col %2 -row %3 -col %4 word %5 line
         UNKNOWN COMMAND        %0 raw text
         VARIABLE UPDATE &lt;VAR&gt;  %0 name %1 new value
         VARIABLE UPDATED &lt;VAR&gt; %0 name %1 new value
         VT100 SCROLL REGION    %0 top row %1 bot row %2 rows %3 cols %4 wrap
         WEEK &lt;DAY&gt;             %2 day of the week
         WINDOW FOCUS IN        %0 name
         WINDOW FOCUS OUT       %0 name
         WRITE ERROR            %0 filename %1 error message
         YEAR                   %0 year

         To see all events trigger use #event info on. Since this can quite
         spammy it's possible to gag event info messages.

</span><span class='l37'>Example</span><span class='d37'>: #event {SESSION CONNECTED} {#read mychar.tin}

</span><span class='l37'>Comment</span><span class='d37'>: You can remove an event with the #unevent command.

</span><span class='l37'>Related</span><span class='d37'>: button, delay and ticker.
<a name='FORALL'></a>

</span><span class='l32'>         FORALL

</span><span class='l37'>This command is obsolete, please use foreach instead.

Related</span><span class='d37'>: cr
<a name='FOREACH'></a>

</span><span class='l32'>         FOREACH

</span><span class='l37'>Command</span><span class='d37'>: #foreach </span><span class='l37'>{</span><span class='d37'>list</span><span class='l37'>} {</span><span class='d37'>variable</span><span class='l37'>} {</span><span class='d37'>commands</span><span class='l37'>}</span><span class='d37'>

         For each item in the provided list the foreach statement will update
         the given variable and execute the command part of the statement. List
         elements must be separated by braces or semicolons.

</span><span class='l37'>Example</span><span class='d37'>: #foreach {bob;tim;kim} {name} {tell &dollar;name Hello}
</span><span class='l37'>Example</span><span class='d37'>: #foreach {{bob}{tim}{kim}} {name} {tell &dollar;name Hello}

</span><span class='l37'>Related</span><span class='d37'>: break, continue, list, loop, parse, repeat, return and while.
<a name='FORMAT'></a>

</span><span class='l32'>         FORMAT

</span><span class='l37'>Command</span><span class='d37'>: #format </span><span class='l37'>{</span><span class='d37'>variable</span><span class='l37'>} {</span><span class='d37'>format</span><span class='l37'>} {</span><span class='d37'>argument1</span><span class='l37'>} {</span><span class='d37'>argument2</span><span class='l37'>} {</span><span class='d37'>etc</span><span class='l37'>}</span><span class='d37'>

         Allows you to store a string into a variable in the exact same way
         C's sprintf works with a few enhancements and limitations such as
         no integer operations and a maximum of 30 arguments.

         If you use #format inside an alias or action you must escape %1s as
         %+1s or %%1s or %&bsol;1s so the %1 isn't substituted by the trigger.

         #format {test} {%+9s} {string}  pad string with up to 9 spaces
         #format {test} {%-9s} {string}  post pad string with up to 9 spaces
         #format {test} {%.8s} {string}  copy at most 8 characters
         #format {test} {%a}   {number}  print corresponding charset character
         #format {test} {%c}   {string}  use a highlight color name
         #format {test} {%d}   {number}  print a number with integer formatting
         #format {test} {%f}   {string}  perform floating point math
         #format {test} {%g}   {number}  perform thousand grouping on {number}
         #format {test} {%h}   {string}  turn text into a header line
         #format {test} {%l}   {string}  lowercase text
         #format {test} {%m}   {string}  perform mathematical calculation
         #format {test} {%n}     {name}  capitalize the first letter
         #format {test} {%p}   {string}  strip leading and trailing spaces
         #format {test} {%r}   {string}  reverse text, hiya = ayih
         #format {test} {%s}   {string}  print given string
         #format {test} {%t}   {format}  display time with strftime format
                                         optional {{format}{time}} syntax
         #format {test} {%u}   {string}  uppercase text
         #format {list} {%w}   {string}  store wordwrapped text in {list}
                                         optional {{string}{width}} syntax
         #format {test} {%x}      {hex}  print corresponding charset character
         #format {test} {%A}     {char}  store corresponding character value
         #format {test} {%D}      {hex}  convert hex to decimal in {test}
         #format {hash} {%H}   {string}  store a 64 bit string hash in {hash}
         #format {test} {%L}   {string}  store the string length in {test}
         #format {time} {%T}         {}  store the epoch time in {time}
         #format {time} {%U}         {}  store the micro epoch time in {time}
         #format {test} {%X}      {dec}  convert dec to hexadecimal in {test}

         #format {test} {%%}             a literal % character

</span><span class='l37'>Comment</span><span class='d37'>: See #help TIME for help on the %t argument.

</span><span class='l37'>Related</span><span class='d37'>: echo, function, local, math, replace, script, time and variable.
<a name='FUNCTION'></a>

</span><span class='l32'>         FUNCTION

</span><span class='l37'>Command</span><span class='d37'>: #function </span><span class='l37'>{</span><span class='d37'>name</span><span class='l37'>} {</span><span class='d37'>operation</span><span class='l37'>}</span><span class='d37'>

         Functions allow you to execute a script within a line of text, and
         replace the function call with the line of text generated by the
         function.

         Be aware that each function should set the &dollar;result variable at the
         end of the function, or call #return with the given result.

         To use a function use the @ character before the function name.
         The function arguments should be placed between braces behind the
         function name with argument separated by semicolons.

         The function itself can use the provided arguments which are stored
         in %1 to %9, with %0 holding all arguments.

</span><span class='l37'>Example</span><span class='d37'>: #function {rnd} {#math {result} {1 d (%2 - %1 + 1) + %1 - 1}}
         #showme A random number between 100 and 200: @rnd{100;200}

</span><span class='l37'>Example</span><span class='d37'>: #function gettime {#format result %t %H:%M}
         #showme The current time is @gettime{}

</span><span class='l37'>Comment</span><span class='d37'>: You can remove a function with the #unfunction command.

</span><span class='l37'>Related</span><span class='d37'>: format, local, math, replace, script and variable.
<a name='GAG'></a>

</span><span class='l32'>         GAG

</span><span class='l37'>Command</span><span class='d37'>: #gag </span><span class='l37'>{</span><span class='d37'>string</span><span class='l37'>}</span><span class='d37'>

         Removes any line that contains the string.

</span><span class='l37'>Comment</span><span class='d37'>: See '#help action', for more information about triggers.

</span><span class='l37'>Comment</span><span class='d37'>: You can remove a gag with the #ungag command.

</span><span class='l37'>Related</span><span class='d37'>: action, highlight, prompt and substitute.
<a name='GREETING'></a>

</span><span class='l32'>         GREETING

</span><span class='d36'>      ####################################################################
      #</span><span class='d37'>                     T I N T I N + +   2.01.92b                   </span><span class='d36'>#
      #</span><span class='d37'>                                                                  </span><span class='d36'>#
      #</span><span class='d37'>                 </span><span class='d36'>T</span><span class='d37'>he K</span><span class='d36'>i</span><span class='d37'>cki</span><span class='d36'>n</span><span class='d37'> </span><span class='d36'>T</span><span class='d37'>ickin D</span><span class='d36'>i</span><span class='d37'>kuMUD Clie</span><span class='d36'>n</span><span class='d37'>t </span><span class='d36'>                #
      #</span><span class='d37'>                                                                  </span><span class='d36'>#
      #</span><span class='d37'>      Code by Peter Unold, Bill Reis, and Igor van den Hoven      </span><span class='d36'>#
      ####################################################################

<a name='GREP'></a>

</span><span class='l32'>         GREP

</span><span class='l37'>Command</span><span class='d37'>: #grep </span><span class='l37'>[</span><span class='d37'>page</span><span class='l37'>] {</span><span class='d37'>search string</span><span class='l37'>}</span><span class='d37'>

         This command allows you to search for matching lines in your scroll
         back buffer. The amount of matches shown equals your screen size. If
         you want to search back further use the optional page number. You can
         use wildcards for better search results. Be aware the search string
         is case sensitive, which can be disabled by using %i.

         By default grep searches from the end of the scrollback buffer to the
         beginning, this can be reversed by using a negative page number.

</span><span class='l37'>Example</span><span class='d37'>: #grep Bubba tells you
         This will show all occasions where bubba tells you something.

</span><span class='l37'>Related</span><span class='d37'>: buffer, echo and showme.
<a name='HELP'></a>

</span><span class='l32'>         HELP

</span><span class='l37'>Command</span><span class='d37'>: #help </span><span class='l37'>{</span><span class='d37'>subject</span><span class='l37'>}</span><span class='d37'>

         Without an argument #help will list all available help subjects.

         Using #help %* will display all help entries.

</span><span class='l37'>Related</span><span class='d37'>: commands, debug, ignore, info, message and statements.
<a name='HIGHLIGHT'></a>

</span><span class='l32'>         HIGHLIGHT

</span><span class='l37'>Command</span><span class='d37'>: #highlight </span><span class='l37'>{</span><span class='d37'>string</span><span class='l37'>} {</span><span class='d37'>color names</span><span class='l37'>}</span><span class='d37'>

         The highlight command is used to allow you to highlight strings of text.

         Available color options are:

         reset      - resets the color state to default
         light      - turns the color light in 16 color mode.
         dark       - turns the color dark in 16 color mode.
         underscore - underscores the text.
         blink      - makes the text blink.
         reverse    - reverse foreground and background color.
         b          - makes next color the background color.

         Available color names are:

         &lt;F06B&gt; - azure                 &lt;F08F&gt; - Azure
         &lt;F00B&gt; - blue                  &lt;F00F&gt; - Blue
         &lt;F0BB&gt; - cyan                  &lt;F0FF&gt; - Cyan
         &lt;F000&gt; - ebony                 &lt;F666&gt; - Ebony
         &lt;F0B0&gt; - green                 &lt;F0F0&gt; - Green
         &lt;F0B6&gt; - jade                  &lt;F0F8&gt; - Jade
         &lt;F6B0&gt; - lime                  &lt;F8F0&gt; - Lime
         &lt;FB0B&gt; - magenta               &lt;FF0F&gt; - Magenta
         &lt;FB60&gt; - orange                &lt;FF80&gt; - Orange
         &lt;FB06&gt; - pink                  &lt;FF08&gt; - Pink
         &lt;FB00&gt; - red                   &lt;FF00&gt; - Red
         &lt;F888&gt; - silver                &lt;FDDD&gt; - Silver
         &lt;F860&gt; - tan                   &lt;FDB0&gt; - Tan
         &lt;F60B&gt; - violet                &lt;F80F&gt; - Violet
         &lt;FBBB&gt; - white                 &lt;FFFF&gt; - White
         &lt;FBB0&gt; - yellow                &lt;FFF0&gt; - Yellow

         The %1-99 variables can be used as 'wildcards' that will match with any
         text. They are useful for highlighting a complete line. The %0 variable
         should never be used in highlights.

         You may start the string to highlight with a ^ to only highlight text
         if it begins the line.

         Besides color names also &lt;abc&gt; color codes can be used.

</span><span class='l37'>Example</span><span class='d37'>: #high {Valgar} {reverse blink}
         Prints every occurrence of 'Valgar' in blinking reverse video.

</span><span class='l37'>Example</span><span class='d37'>: #high {^You %1} {bold cyan}
         Boldfaces any line that starts with 'You' in cyan.

</span><span class='l37'>Example</span><span class='d37'>: #high {Bubba} {red underscore b green}
         Highlights the name Bubba as red underscored text on green background.

</span><span class='l37'>Comment</span><span class='d37'>: See '#help action', for more information about triggers.

</span><span class='l37'>Comment</span><span class='d37'>: See '#help substitute', for more advanced color substitution.

</span><span class='l37'>Comment</span><span class='d37'>: This command only works with ANSI/VT100 terminals or emulators.

</span><span class='l37'>Comment</span><span class='d37'>: You can remove a highlight with the #unhighlight command.

</span><span class='l37'>Related</span><span class='d37'>: action, gag, prompt and substitute.
<a name='HISTORY'></a>

</span><span class='l32'>         HISTORY

</span><span class='l37'>Command</span><span class='d37'>: #history </span><span class='l37'>{</span><span class='d37'>delete</span><span class='l37'>}</span><span class='d37'>                 Delete the last command.
         #history </span><span class='l37'>{</span><span class='d37'>insert</span><span class='l37'>}    {</span><span class='d37'>command</span><span class='l37'>}</span><span class='d37'>    Insert a command.
         #history </span><span class='l37'>{</span><span class='d37'>list</span><span class='l37'>}</span><span class='d37'>                   Display the entire command history.
         #history </span><span class='l37'>{</span><span class='d37'>read</span><span class='l37'>}      {</span><span class='d37'>filename</span><span class='l37'>}</span><span class='d37'>   Read a command history from file.
         #history </span><span class='l37'>{</span><span class='d37'>write</span><span class='l37'>}     {</span><span class='d37'>filename</span><span class='l37'>}</span><span class='d37'>   Write a command history to file.

         Without an argument all available options are shown.

         By default all commands are saved to the history list and the history
         list is saved between sessions in the ~/.tintin/history.txt file.

         You can set the character to repeat a command in the history with the
         #config {REPEAT CHAR} {&lt;character&gt;} configuration option, by default
         this is set to the exclamation mark.

         You can use ! by itself to repeat the last command, or !&lt;text&gt; to
         repeat the last command starting with the given text.

         You can use #config {REPEAT ENTER} {ON} to repeat the last command
         when you press enter on an empty line.

         You can press ctrl-r to enter an interactive regex enabled history
         search mode, or by issueing #cursor {history search}.

         TinTin++ tries to bind the arrow up and down keys to scroll through
         the history list by default. You can bind these with a macro yourself
         using #cursor {history next} and #cursor {history prev}. Many #cursor
         commands only work properly when bound with a macro.

</span><span class='l37'>Related</span><span class='d37'>: alias, cursor, keypad, macro, speedwalk and tab.
<a name='IF'></a>

</span><span class='l32'>         IF

</span><span class='l37'>Command</span><span class='d37'>: #if </span><span class='l37'>{</span><span class='d37'>conditional</span><span class='l37'>} {</span><span class='d37'>commands if true</span><span class='l37'>} {</span><span class='d37'>commands if false</span><span class='l37'>}</span><span class='d37'>

         The 'if' command is one of the most powerful commands added since
         TINTIN III. It works similar to an 'if' statement in other languages,
         and is strictly 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 commands 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 commands.

</span><span class='l37'>Example</span><span class='d37'>: #action {%0 gives you %1 gold coins.} {#if {%1&gt;5000} {thank %0}}
         If someone gives you more than 5000 coins, thank them.

</span><span class='l37'>Comment</span><span class='d37'>: See '#help math', for more information.

</span><span class='l37'>Related</span><span class='d37'>: case, default, else, elseif, switch and regex.
<a name='IGNORE'></a>

</span><span class='l32'>         IGNORE

</span><span class='l37'>Command</span><span class='d37'>: #ignore </span><span class='l37'>{</span><span class='d37'>listname</span><span class='l37'>} {</span><span class='d37'>on</span><span class='l37'>|</span><span class='d37'>off</span><span class='l37'>}</span><span class='d37'>

         Toggles a list on or off. With no arguments it shows your current
         settings, as well as the list names that you can ignore.

         If you for example set ACTIONS to OFF actions will no longer trigger.
         Not every list can be ignored.

</span><span class='l37'>Related</span><span class='d37'>: class, debug, info, kill and message.
<a name='INDEX'></a>

</span><span class='l32'>         INDEX

</span><span class='d37'>         On this page you'll find an introduction to using TinTin++. Additional
         information can be found in the individual help sections.
</span><span class='l32'>
         Starting and Ending
</span><span class='d37'>
         The syntax for starting TinTin++ is: ./tt++ [command file]

         Read more about the command file in the files section below. Remember
         one thing though. All actions, aliases, substitutions, etc, defined
         when starting up TinTin++ are inherited by all sessions.

         If you want to exit TinTin++ type '#end' or press ctrl-d on an empty
         line.

         For the WinTin++ users, if you want to paste text use shift-insert,
         text is automatically copied upon selection. This is typical Linux
         behavior, but it can take some getting used to.

</span><span class='l32'>
         Basic features
</span><span class='d37'>
         I'll start by explaining some of the very basic and important features:

         All TinTin++ commands starts with a '#'.

</span><span class='l37'>Example</span><span class='d37'>: #help -- #help is a mud client command, and isn't send to the mud
         server.

         All TinTin++ commands can be abbreviated when typed.

         #he -- Typing #he is the same as typing #help though it's suggested to
         use at least 3 letter abbreviations just in case another command is
         added that starts with 'he'.

         All commands can be separated with a ';'.

         n;l green;s;say Dan Dare is back! -- do these 4 commands
         There are 3 ways ';'s can be overruled.

         &bsol;say Hello ;) -- Lines starting with a '&bsol;' aren't parsed by TinTin++.
         say Hello &bsol;;) -- The escape character can esape 1 letter.
         #config verbatim on -- Everything is send as is except '#' commands.
</span><span class='l32'>
         Connecting to a mud
</span><span class='l37'>
Command</span><span class='d37'>: #session </span><span class='l37'>{</span><span class='d37'>session name</span><span class='l37'>} {</span><span class='d37'>mud address</span><span class='l37'>} {</span><span class='d37'>port</span><span class='l37'>}</span><span class='d37'>

         Example: #session someone tintin.sourceforge.net 4321

         You can have more than one session, in which case you can switch
         between sessions typing #&lt;session name&gt;.

         You can get a list of all sessions by typing: #session. The current
         active session is marked with (active). Snooped sessions with
         (snooped). MCCP sessions (mud client compression protocol) with
         (mccp 2).

</span><span class='l32'>
         Split
</span><span class='l37'>
Command</span><span class='d37'>: #split

         The split command will create a separated input and output area.

         Using the #prompt command you can capture the prompt and place it on
         the split line. To get rid of the split interface you can use #unsplit
         which will restore the terminal settings to default.

</span><span class='l32'>
         Alias
</span><span class='l37'>
Command</span><span class='d37'>: #alias </span><span class='l37'>{</span><span class='d37'>name</span><span class='l37'>} {</span><span class='d37'>commands</span><span class='l37'>}</span><span class='d37'>

         The syntax of the #alias command is almost like alias in csh.
         Use this command to define aliases. The variables %0, %1.. %9 contain
         the arguments to the aliased command as follows:
         the %0 variable contains ALL the arguments.
         the %1 variable contains the 1st argument
         ....
         the %9 variable contains the 9th argument

</span><span class='l37'>Example</span><span class='d37'>: #alias greet say Greetings, most honorable %1

         If there are no variables on the right-side of the alias definition,
         any arguments following the aliases-command will be appended to the
         command string.

</span><span class='l37'>Example</span><span class='d37'>: #alias ff cast 'fireball' -- 'ff bob' equals: cast 'fireball' bob

         If you want an alias to execute more commands, you must use braces.

</span><span class='l37'>Example</span><span class='d37'>: #alias ws </span><span class='l37'>{</span><span class='d37'>wake;stand</span><span class='l37'>}</span><span class='d37'>

         To delete an alias use the #unalias command.

         WARNING! TinTin++ doesn't baby sit, and hence does not check for
         recursive aliases! You can avoid recursion by escaping the entire
         line.

</span><span class='l37'>Example</span><span class='d37'>: #alias put &bsol;put %1 in %2

         Or by using the send command.

</span><span class='l37'>Example</span><span class='d37'>: #send put %1 in %2


</span><span class='l32'>         Action

</span><span class='l37'>Command</span><span class='d37'>: #action </span><span class='l37'>{</span><span class='d37'>action-text</span><span class='l37'>} {</span><span class='d37'>commands</span><span class='l37'>}</span><span class='d37'>

         Use this command to define an action to take place when a particular
         text appears on your screen. There are 99 variables you can use as
         wildcards in the action-text.

         These variables are %1, %2, %3 .... %9, %10, %11 ... %97, %98, %99.

</span><span class='l37'>Example</span><span class='d37'>: #action </span><span class='l37'>{</span><span class='d37'>You are hungry</span><span class='l37'>} {</span><span class='d37'>get bread bag;eat bread</span><span class='l37'>}</span><span class='d37'>

</span><span class='l37'>Example</span><span class='d37'>: #action </span><span class='l37'>{</span><span class='d37'>%1 has arrived.</span><span class='l37'>}</span><span class='d37'> shake %1 -- shake hands with people arriving.

</span><span class='l37'>Example</span><span class='d37'>: #action </span><span class='l37'>{</span><span class='d37'>%1 tells you '%2'</span><span class='l37'>}
                   {</span><span class='d37'>tell bob %1 told me '%2'</span><span class='l37'>}</span><span class='d37'> -- forward tells.

</span><span class='l37'>Example</span><span class='d37'>: #action </span><span class='l37'>{</span><span class='d37'>tells you</span><span class='l37'>}</span><span class='d37'> #bell -- beep on tell.

         You can have TinTin++ ignore actions if you type '#ignore actions on'.

         You can see what commands TinTin++ executes when an action triggers
         by typing '#debug actions on'.

         You can remove actions with the #unaction command.

</span><span class='l32'>
         Highlight

</span><span class='l37'>Command</span><span class='d37'>: #highlight </span><span class='l37'>{</span><span class='d37'>text</span><span class='l37'>} {</span><span class='d37'>color</span><span class='l37'>}</span><span class='d37'>

         This command works a bit like #action. The purpose of this command is
         to substitute text from the mud with color you provide. This command
         is a simplified version of the #substitute command.

</span><span class='l37'>Example</span><span class='d37'>: #high </span><span class='l37'>{</span><span class='d37'>Snowy</span><span class='l37'>} {</span><span class='d37'>light yellow</span><span class='l37'>}</span><span class='d37'>

</span><span class='l37'>Example</span><span class='d37'>: #high </span><span class='l37'>{</span><span class='d37'>%*Snowy%*</span><span class='l37'>} {</span><span class='d37'>light yellow</span><span class='l37'>}</span><span class='d37'>

         Use #unhigh to delete highlights.


         Speedwalk

         If you type a command consisting ONLY of letters and numbers n, e, s,
         w, u, d - then this command can be interpreted as a serie of movement
         commands.

</span><span class='l37'>Example</span><span class='d37'>: ssw2n -- go south, south, west, north, north

         If you have problems with typing some commands that actually ONLY
         consists of these letters, then type them in CAPS. For example when
         checking the NEWS or when asked to enter NEW as your name.

         You must enable speedwalking with: #config speedwalk on/off.

</span><span class='l32'>
         Ticker

</span><span class='l37'>Command</span><span class='d37'>: #ticker </span><span class='l37'>{</span><span class='d37'>name</span><span class='l37'>} {</span><span class='d37'>commands</span><span class='l37'>} {</span><span class='d37'>seconds</span><span class='l37'>}</span><span class='d37'>

         Every 60 seconds on a standard dikumud a so called tick occures. You
         regenerate hp/mana/move faster if you're sleeping/resting during a
         tick. So it's pretty nice to know when the next tick occures. TinTin++
         helps you with that.

</span><span class='l37'>Example</span><span class='d37'>: #tick </span><span class='l37'>{</span><span class='d37'>tick</span><span class='l37'>} {</span><span class='d37'>#delay 50 #show 10 SECONDS TO TICK!;#show TICK!!!</span><span class='l37'>} {</span><span class='d37'>60</span><span class='l37'>}</span><span class='d37'>

         This creates a ticker with the name </span><span class='l37'>{</span><span class='d37'>tick</span><span class='l37'>}</span><span class='d37'> which will print TICK!!!,
         as well as print a warning when the next tick will occure.

         You can remove tickers with #untick

</span><span class='l32'>
         Command files
</span><span class='d37'>
         When you order TinTin++ to read a command file, it parses all the text
         in the file. You can use command files to keep aliases/actions in,
         login to a mud (name, password etc..) and basically all kinds of
         commands.

         You can make the command files with either a text editor (suggested),
         or use the #write command to write out a file.

         Commands for files:

         #read filename -- read and execute the file.

         #write filename -- write all actions/aliases/substitutes/etc known for
         the current session to a file.

</span><span class='l32'>
         Repeating Commands
</span><span class='d37'>
         You can repeat a command, the syntax is: #number command

</span><span class='l37'>Example</span><span class='d37'>: #5 cackle -- if you just killed bob the wizard.
</span><span class='l37'>Example</span><span class='d37'>: #10 </span><span class='l37'>{</span><span class='d37'>buy bread;put bread bag</span><span class='l37'>}</span><span class='d37'> -- repeat these 2 commands 10 times.
</span><span class='l37'>Example</span><span class='d37'>: #100 ooc w00t w00t!!!!! -- nochannel yourself.

</span><span class='l32'>
         History
</span><span class='d37'>
         TinTin++ has a limited subset of the csh history features.

         ! -- repeat the last command
         !cast -- repeat the last command starting with cast
         ctrl-r -- enter the reverse history search mode.

</span><span class='l32'>
         Map commands
</span><span class='d37'>
         TinTin++ has a powerful highly configurable automapper. Whenever
         you type n/ne/e/se/s/sw/w/nw/n/u/d tt++ tries to keep track of your
         movement.

         Commands for map:

         #map create -- create a map.
         #map goto 1 -- go to the first room in the map, created by default.
         #map map -- display the map.
         #map undo -- undo your last map alteration.
         #map write &lt;filename&gt; -- save the map to file.
         #map read &lt;filename&gt; -- load a map from file.

         There are many other map options and it's beyond the scope of this
         help section to explain everything there is to know, but I'll give
         a set of commands that will get most people started.

         #map create
         #split 12 1
         #map flag unicode on
         #map flag vt on
         #map goto 1

         These commands will create a 12 row vt100 split section at the top of
         your screen where a map drawn using unicode characters is displayed.

</span><span class='l37'>Example</span><span class='d37'>: #action </span><span class='l37'>{</span><span class='d37'>There is no exit in that direction.</span><span class='l37'>} {</span><span class='d37'>#map undo</span><span class='l37'>}</span><span class='d37'>

         The map will be automatically created as you move around.

</span><span class='l32'>
         Help

</span><span class='l37'>Command</span><span class='d37'>: #help </span><span class='l37'>{</span><span class='d37'>subject</span><span class='l37'>}</span><span class='d37'>

         The help command is your friend and contains the same helpfiles
         inside TinTin++ as are available on the website. If you type #help
         without an argument you will see the various available help subjects
         which try to explain the TinTin++ commands and features in greater
         detail.

</span><span class='l32'>
         Enjoy</span><span class='d37'>

<a name='INFO'></a>

</span><span class='l32'>         INFO

</span><span class='l37'>Command</span><span class='d37'>: #info </span><span class='l37'>{</span><span class='d37'>listname</span><span class='l37'>} {</span><span class='d37'>LIST</span><span class='l37'>|</span><span class='d37'>ON</span><span class='l37'>|</span><span class='d37'>OFF</span><span class='l37'>|</span><span class='d37'>SAVE</span><span class='l37'>}</span><span class='d37'>

         Without an argument info displays the settings of every tintin list.

         By providing the name of a list and the LIST option it shows all
         triggers/variables associated with that list. With the SAVE option
         This data is written to the info variable.

         #info cpu will show information about tintin's cpu usage.
         #info system will show some system information.

</span><span class='l37'>Related</span><span class='d37'>: class, debug, ignore, kill and message.
<a name='KEYPAD'></a>

</span><span class='l32'>         KEYPAD

</span><span class='d37'>When TinTin++ starts up it sends &bsol;e= to the terminal to enable the terminal's
application keypad mode, which can be disabled using #showme {&bsol;e&gt;}

</span><span class='l37'>     Configuration A            Configuration B            Configuration C</span><span class='d37'>
+-----+-----+-----+-----+  +-----+-----+-----+-----+  +-----+-----+-----+-----+
|Num  |/    |*    |-    |  |Num  |/    |*    |-    |  |Num  |nkp/ |nkp* |nkp- |
+-----+-----+-----+-----+  +-----+-----+-----+-----+  +-----+-----+-----+-----+
|7    |8    |9    |     |  |Home |Up   |PgUp |     |  |nkp7 |nkp8 |nkp9 |     |
+-----+-----+-----+     |  +-----+-----+-----+     |  +-----+-----+-----+     |
|4    |5    |6    |+    |  |Left |Centr|Right|+    |  |nkp4 |nkp5 |nkp6 |nkp+ |
+-----+-----+-----+-----+  +-----+-----+-----+-----+  +-----+-----+-----+-----+
|1    |2    |3    |     |  |End  |Down |PgDn |     |  |nkp1 |nkp2 |nkp3 |     |
+-----+-----+-----+     |  +-----+-----+-----+     |  +-----+-----+-----+     |
|0          |.    |Enter|  |Ins        |Del  |Enter|  |nkp0       |nkp. |nkpEn|
+-----------+-----+-----+  +-----------+-----+-----+  +-----------+-----+-----+

With keypad mode disabled numlock on will give you configuration A, and numlock
off will give you configuration B. With keypad mode enabled you'll get
configuration C.

</span><span class='l37'>Terminals that support keypad mode
</span><span class='d37'>Linux Console, PuTTY, Eterm, aterm.

</span><span class='l37'>Terminals that do not support keypad mode

</span><span class='d37'>RXVT on Cygwin, Windows Console, Gnome Terminal, Konsole.

</span><span class='l37'>Peculiar Terminals

</span><span class='d37'>RXVT requires turning off numlock to enable configuration C.

Xterm may require disabling Alt/NumLock Modifiers (num-lock) in the ctrl-left
click menu. Or edit ~/.Xresources and add XTerm*VT100.numLock:false

Mac OS X Terminal requires enabling 'strict vt100 keypad behavior' in
Terminal -&gt; Window Settings -&gt; Emulation.

</span><span class='l37'>Related</span><span class='d37'>: colors, coordinates, escape, mathematics and pcre.
<a name='KILL'></a>

</span><span class='l32'>         KILL

</span><span class='l37'>Command</span><span class='d37'>: #kill </span><span class='l37'>{</span><span class='d37'>list</span><span class='l37'>} {</span><span class='d37'>pattern</span><span class='l37'>}</span><span class='d37'>

         Without an argument, the kill command clears all lists.  Useful if
         you don't want to exit tintin to reload your command files.

         With one argument a specific list can be cleared.

         With two arguments the triggers in the chosen list that match the
         given pattern will be removed.

</span><span class='l37'>Example</span><span class='d37'>: #kill alias %*test*

</span><span class='l37'>Related</span><span class='d37'>: class, debug, ignore, info and message.
<a name='LINE'></a>

</span><span class='l32'>         LINE

</span><span class='l37'>Command</span><span class='d37'>: #line </span><span class='l37'>{</span><span class='d37'>option</span><span class='l37'>} {</span><span class='d37'>argument</span><span class='l37'>}</span><span class='d37'>

         </span><span class='l37'>#line background &lt;argument&gt;
         </span><span class='d37'>  Prevent new session activation.

         </span><span class='l37'>#line debug &lt;argument&gt;
         </span><span class='d37'>  Argument is executed in debug mode.

         </span><span class='l37'>#line gag
         </span><span class='d37'>                Gag the next line.

         </span><span class='l37'>#line ignore {argument}
         </span><span class='d37'>  Argument is executed without any triggers being checked.

         </span><span class='l37'>#line log &lt;filename&gt; [text]
         </span><span class='d37'>  Log the next line to file unless the [text] argument is
           provided.

         </span><span class='l37'>#line logmode &lt;option&gt; &lt;argument&gt;
         </span><span class='d37'>  Argument is executed using the provided logmode, available
           modes are: html, plain, and raw.

         </span><span class='l37'>#line oneshot &lt;argument&gt;
         </span><span class='d37'>  Argument is executed in oneshot mode, all triggers created will
           only fire once.

         </span><span class='l37'>#line quiet &lt;argument&gt;
         </span><span class='d37'>  Argument is executed with suppression of most system messages.

         </span><span class='l37'>#line strip &lt;argument&gt;
         </span><span class='d37'>  Argument is executed with all color codes stripped.

         </span><span class='l37'>#line substitute &lt;options&gt; &lt;argument&gt;
         </span><span class='d37'>  Argument is executed using the provided substitutions, available
           options are: arguments, colors, escapes, functions, secure, and
           variables.

         </span><span class='l37'>#line verbatim &lt;argument&gt;
         </span><span class='d37'>  Argument is executed verbatim, prohibiting variable and function
           substitutions.

         </span><span class='l37'>#line verbose &lt;argument&gt;
         </span><span class='d37'>  Argument is executed with most system messages enabled.

         When using #line log and logging in html format use &bsol;c&lt; &bsol;c&gt; &bsol;c&amp; &bsol;c&quot; to
         log a literal &lt; &gt; &amp; and &quot;.

</span><span class='l37'>Related</span><span class='d37'>: class and config.
<a name='LIST'></a>

</span><span class='l32'>         LIST

</span><span class='l37'>Command</span><span class='d37'>: #list </span><span class='l37'>{</span><span class='d37'>variable</span><span class='l37'>} {</span><span class='d37'>option</span><span class='l37'>} {</span><span class='d37'>argument</span><span class='l37'>}</span><span class='d37'>

         #list {var} {add} {item}               Add {item} to the list
         #list {var} {clear}                    Empty the given list
         #list {var} {create} {item}            Create a list using {items}
         #list {var} {delete} {index} {number}  Delete the item at {index},
                                                the {number} is optional.
         #list {var} {insert} {index} {string}  Insert {string} at given index
         #list {var} {find} {string} {variable} Return the found index
         #list {var} {get} {index} {variable}   Copy an item to {variable}
         #list {var} {set} {index} {string}     Change the item at {index}
         #list {var} {simplify} {variable}      Copy simple list to {variable}
         #list {var} {size} {variable}          Copy list size to {variable}
         #list {var} {sort} {string}            Insert item in alphabetic order
         #list {var} {tokenize} {string}        Create a character list

         The index should be between 1 and the list's length. You can also give
         a negative value, in which case -1 equals the last item in the list, -2
         the second last, etc.

         When inserting an item a positive index will prepend the item at the
         given index, while a negative index will append the item.

         The add and create options allow using multiple items, as well
         as semicolon separated items.

         A length of 0 is returned for an empty or non existant list.

         You can directly access elements in a list variable using &dollar;var[1],
         &dollar;var[2], &dollar;var[-1], etc.

</span><span class='l37'>Related</span><span class='d37'>: break, continue, foreach, loop, parse, repeat, return and while.
<a name='LOCAL'></a>

</span><span class='l32'>         LOCAL

</span><span class='l37'>Command</span><span class='d37'>: #local </span><span class='l37'>{</span><span class='d37'>variable name</span><span class='l37'>} {</span><span class='d37'>text to fill variable</span><span class='l37'>}</span><span class='d37'>

         The local command sets a local variable. Unlike a regular variable
         a local variable will only stay in memory for the duration of the
         event that created it. They are accessed in the same way as a
         regular variable.

         Commands that store information to a variable will use a local variable
         if it exists.

         Avoid setting the result variable as local in a function.

</span><span class='l37'>Example</span><span class='d37'>: #alias {swap} {#local x %0;#replace x {e} {u};#showme &dollar;x}

</span><span class='l37'>Related</span><span class='d37'>: format, function, math, replace, script and variable.
<a name='LOG'></a>

</span><span class='l32'>         LOG

</span><span class='l37'>Command</span><span class='d37'>: #log </span><span class='l37'>{</span><span class='d37'>append</span><span class='l37'>|</span><span class='d37'>overwrite</span><span class='l37'>} {</span><span class='d37'>filename</span><span class='l37'>}</span><span class='d37'>

         Logs session to a file, you can set the data type to either plain,
         raw, or html with the config command.

</span><span class='l37'>Related</span><span class='d37'>: read, scan, textin and write.
<a name='LOOP'></a>

</span><span class='l32'>         LOOP

</span><span class='l37'>Command</span><span class='d37'>: #loop </span><span class='l37'>{</span><span class='d37'>&lt;start&gt;</span><span class='l37'>} {</span><span class='d37'>&lt;finish&gt;</span><span class='l37'>} {</span><span class='d37'>&lt;variable&gt;</span><span class='l37'>} {</span><span class='d37'>commands</span><span class='l37'>}</span><span class='d37'>

         Like a for statement, loop will loop from start to finish incrementing
         or decrementing by 1 each time through.  The value of the loop counter
         is stored in the provided variable, which you can use in the commands.

</span><span class='l37'>Example</span><span class='d37'>: #loop 1 3 loop {get all &dollar;loop&bsol;.corpse}
         This equals 'get all 1.corpse;get all 2.corpse;get all 3.corpse'.

         The . needs to be escaped so it's not treated as part of the variable.

</span><span class='l37'>Example</span><span class='d37'>: #loop 3 1 cnt {drop &dollar;cnt&bsol;.key}
         This equals 'drop 3.key;drop 2.key;drop 1.key'.

</span><span class='l37'>Related</span><span class='d37'>: break, continue, foreach, list, parse, repeat, return and while.
<a name='MACRO'></a>

</span><span class='l32'>         MACRO

</span><span class='l37'>Command</span><span class='d37'>: #macro </span><span class='l37'>{</span><span class='d37'>key sequence</span><span class='l37'>} {</span><span class='d37'>commands</span><span class='l37'>}</span><span class='d37'>

         Macros allow you to make tintin respond to function keys.

         The key sequence send to the terminal when pressing a function key
         differs for every OS and terminal. To find out what sequence is send
         you can enable the CONVERT META config option.

         Another option is pressing ctrl-v, which will enable CONVERT META for
         the next key pressed.

         If you only want a key sequence to trigger at the start of an input
         line prefix the key sequence with ^.

</span><span class='l37'>Example</span><span class='d37'>: #macro {(press ctrl-v)(press F1)} {#showme &bsol;e[2J;#buffer lock}
         Clear the screen and lock the window when you press F1, useful when the
         boss is near.

</span><span class='l37'>Example</span><span class='d37'>: #macro {&bsol;eOM} {#cursor enter}
         Makes the keypad's enter key work as an enter in keypad mode.

</span><span class='l37'>Example</span><span class='d37'>: #macro {^nn} {n}
         Makes pressing n twice on an empty line execute north.

</span><span class='l37'>Comment</span><span class='d37'>: Not all terminals properly initialize the keypad key sequences.
         If this is the case you can still use the keypad, but instead of the
         arrow keys use ctrl b, f, p, and n.

</span><span class='l37'>Comment</span><span class='d37'>: You can remove a macro with the #unmacro command.

</span><span class='l37'>Related</span><span class='d37'>: alias, cursor, history, keypad, speedwalk and tab.
<a name='MAP'></a>

</span><span class='l32'>         MAP

</span><span class='l37'>Command</span><span class='d37'>: #map

         The map command is the backbone of the auto mapping feature.

         </span><span class='l37'>#map at &lt;exit|vnum&gt; &lt;command&gt;
         </span><span class='d37'>  Execute the command at the given exit or vnum.

         </span><span class='l37'>#map center &lt;x&gt; &lt;y&gt; &lt;z&gt;
         </span><span class='d37'>  Sets displaying center of the map viewer, default is 0 0 0.

         </span><span class='l37'>#map color &lt;field&gt; [value]
         </span><span class='d37'>  Sets the map color for the given color field.

         </span><span class='l37'>#map create &lt;size&gt;
         </span><span class='d37'>  Creates a new map and room 1. The default size is 50000 rooms.

         </span><span class='l37'>#map destroy
         </span><span class='d37'>  Deletes the map.

         </span><span class='l37'>#map delete &lt;exit|vnum&gt;
         </span><span class='d37'>  Deletes the room for the given exit or vnum.

         </span><span class='l37'>#map dig &lt;exit|vnum&gt; [new|&lt;vnum&gt;]
         </span><span class='d37'>  Creates an exit for the given exit name. If no valid exit name
           is given or no existing room is found a new room is created.
           Useful for portal links and other alternative forms of
           transportation. If the 'new' argument is provided all existing
           rooms are ignored and a new room is created. If a room vnum is
           given as the second argument an exit will be created leading
           to the given room vnum. If the room vnum doesn't exist a new
           room is created.

         </span><span class='l37'>#map exit &lt;exit&gt; &lt;option&gt; &lt;arg&gt;
         </span><span class='d37'>  Set the exit data. Useful with a closed door where you can
           set the exit command: '#map exit e command {open east;e}'.
           Use #map exit &lt;exit&gt; for a list of available options.

         </span><span class='l37'>#map exitflag &lt;exit&gt; &lt;HIDE|AVOID&gt; [on|off]
         </span><span class='d37'>  Set exit flags. See #map roomflag for more info.

         </span><span class='l37'>#map explore &lt;exit&gt;
         </span><span class='d37'>  Explores the given exit until a dead end or an
           intersection is found. The route is stored in #path and can
           subsequently be used with #walk. Useful for long roads.

         </span><span class='l37'>#map find &lt;name&gt; &lt;exits&gt; &lt;desc&gt; &lt;area&gt; &lt;note&gt; &lt;terrain&gt; &lt;flag&gt;
         </span><span class='d37'>  searches for the given room name. If found the shortest path
           from your current location to the destination is calculated.
           The route is stored in #path and can subsequently be used with
           the various #path commands. If &lt;exits&gt; is provided all exits
           must be matched, if &lt;roomdesc&gt;, &lt;roomarea&gt; or &lt;roomnote&gt; or
           &lt;roomterrain&gt; or &lt;roomflag&gt; is provided these are matched as
           well against the room to be found.
           These options are also available to the at, delete, goto
           link, list and run commands.

         </span><span class='l37'>#map flag asciigraphics
         </span><span class='d37'>  Takes up more space but draws a more detailed
           map that displays the ne se sw nw exits and room symbols.

         </span><span class='l37'>#map flag asciivnums
         </span><span class='d37'>  Display room vnums if asciigraphics is enabled.

         </span><span class='l37'>#map flag nofollow
         </span><span class='d37'>  When you enter movement commands the map will no longer
           automatically follow along. Useful for MSDP and GMCP
           automapping scripts.

         </span><span class='l37'>#map flag static
         </span><span class='d37'>  Will make the map static so new rooms are no longer
           created when walking into an unmapped direction. Useful when
           you're done mapping and regularly bump into walls accidentally
           creating a new room. #map dig etc will still work.

         </span><span class='l37'>#map flag vtgraphics
         </span><span class='d37'>  Enables vt line drawing on some terminals

         </span><span class='l37'>#map flag vtmap
         </span><span class='d37'>  Will enable the vtmap which is shown in the top split
           screen if you have one. You can create a 16 rows high top
           screen by using '#split 16 1'.

         </span><span class='l37'>#map get &lt;option&gt; &lt;variable&gt; [vnum]
         </span><span class='d37'>  Store a map value into a variable, if no vnum is given the
           current room is used. Use 'all' as the option to store all
           values as a table.

         </span><span class='l37'>#map get roomexits &lt;variable&gt;
         </span><span class='d37'>  Store all room exits into variable.

         </span><span class='l37'>#map global &lt;room vnum&gt;
         </span><span class='d37'>  Set the vnum of a room that contains global
           exits, for example an exit named 'recall' that leads to the
           recall location. The room can contain multiple exits, in case
           there are multiple commands that are similar to recall.

         </span><span class='l37'>#map goto &lt;room vnum&gt; [dig]
         </span><span class='d37'>  Takes you to the given room vnum, with the
           dig argument a new room will be created if none exists.

         </span><span class='l37'>#map goto &lt;name&gt; &lt;exits&gt; &lt;desc&gt; &lt;area&gt; &lt;note&gt; &lt;terrain&gt;
         </span><span class='d37'>  Takes you to the given room name, if you provide exits those
           must match.

         </span><span class='l37'>#map info
         </span><span class='d37'>  Gives information about the map and room you are in.

         </span><span class='l37'>#map insert &lt;direction&gt; [roomflag]
         </span><span class='d37'>  Insert a room in the given direction. Most useful for inserting
           void rooms.

         </span><span class='l37'>#map jump &lt;x&gt; &lt;y&gt; &lt;z&gt;
         </span><span class='d37'>  Jump to the given coordinate, which is relative
           to your current room.

         </span><span class='l37'>#map leave
         </span><span class='d37'>  Makes you leave the map. Useful when entering a maze. You
           can return to your last known room using #map return.

         </span><span class='l37'>#map legend &lt;legend&gt; [symbols|reset]
         #map legend &lt;legend&gt; &lt;index&gt; [symbol]
         </span><span class='d37'>  There are several legends and sub-legends available for
           drawing maps to suit personal preference and character sets.
           Use #map legend all to see the legend as currently defined.
           Use #map legend &lt;legend&gt; &lt;reset&gt; to set the default legend.
           Use #map legend &lt;legend&gt; &lt;character list&gt; to create a custom
           legend. Custom legends are automatically saved and loaded by
           using #map read and #map write.

         </span><span class='l37'>#map link &lt;direction&gt; &lt;room name&gt; [both]
         </span><span class='d37'>  Links two rooms. If the both
           argument and a valid direction is given the link is two ways.

         </span><span class='l37'>#map list &lt;name&gt; &lt;exits&gt; &lt;desc&gt; &lt;area&gt; &lt;note&gt; &lt;terrain&gt;
         </span><span class='d37'>  Lists all matching rooms and their distance. The following
           search keywords are supported.

           {roomarea}    &lt;arg&gt; will list rooms with matching area name.
           {roomdesc}    &lt;arg&gt; will list rooms with matching room desc.
           {roomexits}   &lt;arg&gt; will list rooms with identical room exits.
           {roomflag}    &lt;arg&gt; will list rooms with matching room flags.
           {roomid}      &lt;arg&gt; will list rooms with identical id name.
           {roomname}    &lt;arg&gt; will list rooms with matching room name.
           {roomnote}    &lt;arg&gt; will list rooms with matching room note.
           {roomterrain} &lt;arg&gt; will list rooms with matching room terrain.
           {variable}    &lt;arg&gt; will save the output to given variable.

         </span><span class='l37'>#map map &lt;rows&gt; &lt;cols&gt; &lt;append|overwrite|list|variable&gt; &lt;name&gt;
         </span><span class='d37'>  Display a drawing of the map of the given height and width.
           All arguments are optional. If {rows} or {cols} are set to {}
           or {0} they will use the scrolling window size as the default.
           If {rows} or {cols} are a negative number this number is
           subtracted from the scrolling window size.

         </span><span class='l37'>#map map &lt;rows&gt; &lt;cols&gt; draw &lt;square&gt;
         </span><span class='d37'>  Display a drawing of the map of the given height and width.
           The square argument exists of 4 numbers formulating the top
           left corner and bottom right corner of a square.

           If you use {append|overwrite} the map is written to the specified
           file name which must be given as the 4th argument.
           If you use {list|variable} the map is saved to the specified
           variable name.

         </span><span class='l37'>#map move &lt;direction&gt;
         </span><span class='d37'>  This does the same as an actual movement
           command, updating your location on the map and creating new
           rooms. Useful when you are following someone and want the map
           to follow. You will need to create actions using '#map move',
           for this to work.

         </span><span class='l37'>#map offset &lt;row&gt; &lt;col&gt; &lt;row&gt; &lt;col&gt;
         </span><span class='d37'>  Define the offset of the vtmap as a square. Without an argument
           it defaults to the entire top split region.

         </span><span class='l37'>#map read &lt;filename&gt;
         </span><span class='d37'>  Will load the given map file.

         </span><span class='l37'>#map resize &lt;size&gt;
         </span><span class='d37'>  Resize the map, setting the maximum number of rooms.

         </span><span class='l37'>#map return
         </span><span class='d37'>  Returns you to your last known room after leaving the map
           or loading a map.

         </span><span class='l37'>#map roomflag &lt;flags&gt; &lt;get|on|off&gt;
         </span><span class='d37'>
         </span><span class='l37'>#map roomflag avoid
         </span><span class='d37'>  When set, '#map find' will avoid a route leading
           through that room. Useful when you want to avoid death traps.
         </span><span class='l37'>#map roomflag hide
         </span><span class='d37'>  When set, '#map' will not display the map beyond
           this room. When mapping overlapping areas or areas that aren't
           build consistently you need this flag as well to stop
           auto-linking, unless you use void rooms.
         </span><span class='l37'>#map roomflag leave
         </span><span class='d37'>  When entering a room with this flag, you will
           automatically leave the map. Useful when set at the entrance
           of an unmappable maze.
         </span><span class='l37'>#map roomflag noglobal
         </span><span class='d37'>  This marks a room as not allowing global
           transportation, like norecall rooms that block recall.
         </span><span class='l37'>#map roomflag void
         </span><span class='d37'>  When set the room becomes a spacing room that can
           be used to connect otherwise overlapping areas. A void room
           should only have two exits. When entering a void room you are
           moved to the connecting room until you enter a non void room.
         </span><span class='l37'>#map roomflag static
         </span><span class='d37'>  When set the room will no longer be autolinked
           when walking around. Useful for mapping mazes.

         </span><span class='l37'>#map run &lt;room name&gt; [delay]
         </span><span class='d37'>  Calculates the shortest path to the destination and walks you
           there. The delay is optional and requires using braces. Besides
           the room name a list of exits can be provided for more precise
           matching.

         </span><span class='l37'>#map set &lt;option&gt; &lt;value&gt; [vnum]
         </span><span class='d37'>  Set a map value for your current room, or given room if a room
           vnum is provided.

         </span><span class='l37'>#map travel &lt;direction&gt; &lt;delay&gt;
         </span><span class='d37'>  Follows the direction until a dead end or an intersection is
           found. Use braces around the direction if you use the delay,
           which will add the given delay between movements.
           Use #path stop to stop a delayed run.

         </span><span class='l37'>#map undo
         </span><span class='d37'>  Will undo your last move. If this created a room or a link
           they will be deleted, otherwise you'll simply move back a
           room. Useful if you walked into a non existant direction.

         </span><span class='l37'>#map uninsert &lt;direction&gt;
         </span><span class='d37'>  Exact opposite of the insert command.

         </span><span class='l37'>#map unlink &lt;direction&gt; [both]
         </span><span class='d37'>  Will remove the exit, this isn't two way so you can have the
           properly display no exit rooms and mazes.
           If you use the both argument the exit is removed two-ways.

         </span><span class='l37'>#map update
         </span><span class='d37'>  Sets the vtmap to update within the next 0.1 seconds.

         </span><span class='l37'>#map vnum &lt;low&gt; [high]
         </span><span class='d37'>  Change the room vnum to the given number, if a range is
           provided the first available room in that range is selected.

         </span><span class='l37'>#map write &lt;filename&gt; [force]
         </span><span class='d37'>  Will save the map, if you want to save a map to a .tin file
           you must provide the {force} argument.

</span><span class='l37'>Related</span><span class='d37'>: path and pathdir.
<a name='MATH'></a>

</span><span class='l32'>         MATH

</span><span class='l37'>Command</span><span class='d37'>: #math </span><span class='l37'>{</span><span class='d37'>variable</span><span class='l37'>} {</span><span class='d37'>expression</span><span class='l37'>}</span><span class='d37'>

         Performs math operations and stores 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       Priority     Function
         ------------------------------------------------
         !               0            logical not
         ~               0            bitwise not
         *               1            integer multiply
         **              1            integer power
         /               1            integer divide
         //              1            integer sqrt // 2 or cbrt // 3
         %               1            integer modulo
         d               1            integer random dice roll
         +               2            integer addition
         -               2            integer subtraction
         &lt;&lt;              3            bitwise shift
         &gt;&gt;              3            bitwise shift
         ..              3            bitwise ellipsis
         &gt;               4            logical greater than
         &gt;=              4            logical greater than or equal
         &lt;               4            logical less than
         &lt;=              4            logical less than or equal
         ==              5            logical equal (can use regex)
         ===             5            logical equal (never regex)
         !=              5            logical not equal (can use regex)
         !==             5            logical not equal (never regex)
          &amp;              6            bitwise and
          ^              7            bitwise xor
          |              8            bitwise or
         &amp;&amp;              9            logical and
         ^^             10            logical xor
         ||             11            logical or

         True is any non-zero number, and False is zero.  Parentheses () have
         highest precedence, so inside the () is always evaluated first.
         Strings must be enclosed in { } and use regex with == and !=,
         in the case of &lt;= and &gt;= the alphabetic order is compared.

         The #if and #switch commands use #math. Several commands accepting
         integer input allow math operations as well.

         Floating point precision is added by using the decimal . operator.
         Time in seconds is calculated using [day]:[hour]:&lt;minute&gt;:&lt;second&gt;.

</span><span class='l37'>Example</span><span class='d37'>: #math {heals} {&dollar;mana / 40}
         Assuming there is a variable &dollar;mana, divides its value by 40 and stores
         the result in &dollar;heals.

</span><span class='l37'>Example</span><span class='d37'>: #action {^You receive %0 experience} {updatexp %0}
         #alias updatexp {#math {xpneed} {&dollar;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.

</span><span class='l37'>Example</span><span class='d37'>: #action {%0 tells %1}
           {#if {{%0} == {Bubba} &amp;&amp; &dollar;afk} {reply I'm away, my friend.}}
         When you are away from keyboard, it will only reply to your friend.

</span><span class='l37'>Related</span><span class='d37'>: format, function, local, mathematics, replace, script and variable.
<a name='MATHEMATICS'></a>

</span><span class='l32'>         MATHEMATICS

</span><span class='l37'>Number operations
</span><span class='d37'>         Operators       Priority     Function
         ------------------------------------------------
         !               0            logical not
         ~               0            bitwise not
         *               1            integer multiply
         **              1            integer power
         /               1            integer divide
         //              1            integer sqrt // 2 or cbrt // 3
         %               1            integer modulo
         d               1            integer random dice roll
         +               2            integer addition
         -               2            integer subtraction
         &lt;&lt;              3            bitwise shift
         &gt;&gt;              3            bitwise shift
         &gt;               4            logical greater than
         &gt;=              4            logical greater than or equal
         &lt;               4            logical less than
         &lt;=              4            logical less than or equal
         ==              5            logical equal
         !=              5            logical not equal
          &amp;              6            bitwise and
          ^              7            bitwise xor
          |              8            bitwise or
         &amp;&amp;              9            logical and
         ^^             10            logical xor
         ||             11            logical or

Operator priority can be ignored by using paranthesis, for example (1 + 1) * 2
equals 4, while 1 + 1 * 2 equals 3.

</span><span class='l37'>String operations</span><span class='d37'>
         Operators       Priority     Function
         ------------------------------------------------
         &gt;               4            alphabetical greater than
         &gt;=              4            alphabetical greater than or equal
         &lt;               4            alphabetical less than
         &lt;=              4            alphabetical less than or equal
         ==              5            alphabetical equal (can use regex)
         !=              5            alphabetical not equal (can use regex)

Strings must be encased in double quotes or braces. The &gt; &gt;= &lt; &lt;= operators
perform basic string comparisons. The == != operators perform regular
expressions, with the argument on the left being the string, and the argument
on the right being the regex. For example {bla} == {%*a} would evaluate as 1.

</span><span class='l37'>Related</span><span class='d37'>: math
<a name='MESSAGE'></a>

</span><span class='l32'>         MESSAGE

</span><span class='l37'>Command</span><span class='d37'>: #message </span><span class='l37'>{</span><span class='d37'>listname</span><span class='l37'>} {</span><span class='d37'>on</span><span class='l37'>|</span><span class='d37'>off</span><span class='l37'>}</span><span class='d37'>

         This will show the message status of all your lists if typed without an
         argument. If you set for example VARIABLES to OFF you will no longer be
         spammed when correctly using the #VARIABLE and #UNVARIABLE commands.

</span><span class='l37'>Related</span><span class='d37'>: class, debug, ignore, info and kill.
<a name='MSDP'></a>

</span><span class='l32'>         MSDP

</span><span class='d37'>
         MSDP is part of the #port functionality. See #help event for
         additional documentation as all MSDP events are available as
         regular events.

         Available MSDP events can be queried using the MSDP protocol
         as described in the specification.
</span><span class='l37'>
         https://tintin.sourceforge.io/protocols/msdp

Related</span><span class='d37'>: event and port.
<a name='NOP'></a>

</span><span class='l32'>         NOP

</span><span class='l37'>Command</span><span class='d37'>: #nop </span><span class='l37'>{</span><span class='d37'>whatever</span><span class='l37'>}</span><span class='d37'>

         Short for 'no operation', and 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. You shouldn't put braces { } in it
         though, unless you close them properly.

</span><span class='l37'>Comment</span><span class='d37'>: By using braces you can comment out multiple lines of code in a script
         file.

         For commenting out an entire trigger and especially large sections of
         triggers you would want to use /* text */

</span><span class='l37'>Example</span><span class='d37'>: #nop This is the start of my script file.

</span><span class='l37'>Related</span><span class='d37'>: read
<a name='PARSE'></a>

</span><span class='l32'>         PARSE

</span><span class='l37'>Command</span><span class='d37'>: #parse </span><span class='l37'>{</span><span class='d37'>string</span><span class='l37'>} {</span><span class='d37'>variable</span><span class='l37'>} {</span><span class='d37'>commands</span><span class='l37'>}</span><span class='d37'>

         Like the loop statement, parse will loop from start to finish through
         the given string.  The value of the current character is stored in the
         provided variable.

</span><span class='l37'>Example</span><span class='d37'>: #parse {hello world} {char} {#showme &dollar;char}

</span><span class='l37'>Related</span><span class='d37'>: break, continue, foreach, list, loop, repeat, return and while.
<a name='PATH'></a>

</span><span class='l32'>         PATH

</span><span class='l37'>Command</span><span class='d37'>: #path </span><span class='l37'>{</span><span class='d37'>option</span><span class='l37'>} {</span><span class='d37'>argument</span><span class='l37'>}</span><span class='d37'>

         create   Will clear the path and start path mapping.
         delete   Will delete the last move of the path.
         describe Describe the path and current position.
         destroy  Will clear the path and stop path mapping.
         goto     Go the the start, end, or given position index.
         insert   Add the given argument to the path.
         load     Load the given variable as the new path.
         map      Display the map and the current position.
         move     Move the position forward or backward. If a number is given
                  the position is changed by the given number of steps.
         run      Execute the current path, with an optional floating point
                  delay in seconds as the second argument.
         save     Save the path to a variable. You must specify whether you
                  want to save the path 'forward' or 'backward'. If you use
                  the 'length' or 'position' keywords the current length or
                  position is saved.
         swap     Switch the forward and backward path.
         unzip    Load the given speedwalk as the new path.
         walk     Take one step forward or backward.
         zip      Turn the path into a speedwalk.

</span><span class='l37'>Example</span><span class='d37'>: #path ins {unlock n;open n} {unlock s;open s}

</span><span class='l37'>Related</span><span class='d37'>: map and pathdir.
<a name='PATHDIR'></a>

</span><span class='l32'>         PATHDIR

</span><span class='l37'>Command</span><span class='d37'>: #pathdir </span><span class='l37'>{</span><span class='d37'>dir</span><span class='l37'>} {</span><span class='d37'>reversed dir</span><span class='l37'>} {</span><span class='d37'>coord</span><span class='l37'>}</span><span class='d37'>

         By default tintin sets the most commonly used movement commands
         meaning you generally don't really have to bother with pathdirs.
         Pathdirs are used by the #path and #map commands.

         The first argument is a direction, the second argument is the reversed
         direction.  The reverse direction of north is south, etc.

         The third argument is a spatial coordinate which is a power of two.
         'n' is 1, 'e' is 2, 's' is 4, 'w' is '8', 'u' is 16, 'd' is 32. The
         exception is for compound directions, whose value should be the sum
         of the values of each cardinal direction it is composed of. For
         example, 'nw' is the sum of 'n' and 'w' which is 1 + 8, so 'nw'
         needs to be given the value of 9. This value is required for the
         #map functionality to work properly.

</span><span class='l37'>Example</span><span class='d37'>: #pathdir {ue} {dw} {18}
         #pathdir {dw} {ue} {40}

</span><span class='l37'>Comment</span><span class='d37'>: You can remove a pathdir with the #unpathdir command.

</span><span class='l37'>Related</span><span class='d37'>: map and path.
<a name='PCRE'></a>

</span><span class='l32'>         PCRE

</span><span class='d37'>
         A regular expression, regex or regexp is a sequence of characters that
         defines a search pattern. Since the 1980s, different syntaxes for
         writing regular expressions exist, the two most widely used ones being
         the POSIX syntax and the similar but more advanced Perl standard.
         TinTin++ supports the Perl standard known as PCRE (Perl Compatible
         Regular Expressions).

         Regular expressions are an integral part of TinTin++, but keep in mind
         that tintin doesn't allow you to use regular expressions directly,
         instead it uses a simpler intermediate syntax that still allows more
         complex expressions when needed.

         Commands that utilize regular expressions are: action, alias, elseif,
         gag, grep, highlight, if, kill, local, math, prompt, regexp, replace,
         substitute, switch, variable and while. Several other commands use
         regular expressions in minor ways. Fortunately the basics are very
         easy to learn.

</span><span class='l37'>         TinTin++ Regular Expression</span><span class='d37'>

         The following support is available for regular expressions.

       ^ match start of line.
       &dollar; match of end of line.
       &bsol; escape one character.

  %1-%99 match of any text, stored in the corresponding index.
      %0 should be avoided in the regex, contains all matched text.
     { } embed a perl compatible regular expression, matches are stored.
   %!{ } embed a perc compatible regular expression, matches are not stored.

[ ] . + | ( ) ? * are treated as normal text unless used within braces. Keep in
mind that { } is replaced with ( ) automatically unless %!{ } is used.
</span><span class='l37'>
         TinTin++  Description                            POSIX</span><span class='d37'>
      %d Match zero to any number of digits               ([0-9]*?)
      %D Match zero to any number of non-digits           ([^0-9]*?)
      %i Matches become case insensitive                  (?i)
      %I Matches become case sensitive (default)          (?-i)
      %s Match zero to any number of spaces               ([&bsol;r&bsol;n&bsol;t ]*?)
      %w Match zero to any number of word characters      ([A-Za-z0-9_]*?)
      %W Match zero to any number of non-word characters  ([^A-Za-z0-9_]*?)
      %? Match zero or one character                      (.??)
      %. Match one character                              (.)
      %+ Match one to any number of characters            (.+?)
      %* Match zero to any number of characters           (.*?)
</span><span class='l37'>
         Variables</span><span class='d37'>

         If you use %1 in an action to perform a match the matched string is
         stored in the %1 variable which can be used in the action body.

Example: %1 says 'Tickle me'} {tickle %1}

         If you use %2 the match is stored in %2, etc. If you use an unnumbered
         match like %* or %S the match is stored at the last used index
         incremented by one.

Example: %3 says '%*'} {#if {&quot;%4&quot; == &quot;Tickle me&quot;} {tickle %3}}

         The maximum variable index is 99. If you begin an action with %* the
         match is stored in %1. You should never use %0 in the trigger part of
         an action, when used in the body of an action %0 contains all the parts
         of the string that were matched.

         To prevent a match from being stored use %!*, %!w, etc.
</span><span class='l37'>
         Perl Compatible Regular Expressions</span><span class='d37'>

         You can embed a PCRE (Perl Compatible Regular Expression) using curley
         braces { }, these braces are replaced with paranthesis ( ) unless you
         use %!{ }.
</span><span class='l37'>
         Or</span><span class='d37'>

         You can separate alternatives within a PCRE using the | character.

Example: #act {%* raises {his|her|its} eyebrows.} {say 42..}
</span><span class='l37'>
         Brackets</span><span class='d37'>

         You can group alternatives and ranges within a PCRE using brackets.

Example: #act {%* says 'Who is number {[1-9]}} {say &dollar;number[%2] is number %2}

         The example only triggers if someone provides a number between 1 and
         9. Any other character will cause the action to not trigger.

Example: #act {%* says 'Set password to {[^0-9]*}&dollar;} {say The password must
           contain at least one number, not for security reasons, but just to
           annoy you.} {4}

         When the ^ character is used within brackets it creates an inverse
         search, [^0-9] matches every character except for a number between 0
         and 9.
</span><span class='l37'>
         Quantification</span><span class='d37'>

         A quantifier placed after a match specifies how often the match is
         allowed to occur.

       ? repeat zero or one time.
       * repeat zero or multiple times.
       + repeat once or multiple times.
     {n} repeat exactly n times, n must be a number.
    {n,} repeat at least n times, n must be a number.
   {n,o} repeat between n and o times, n and o must be a number.

Example: #act {%* says 'Who is number {[1-9][0-9]{0,2}} {Say &dollar;number[%2] is
           number %2}

         The example only triggers if someone provides a number between 1 and
         999.

         </span><span class='l37'>Paranthesis</span><span class='d37'>

         TinTin Regular Expressions automatically add parenthesis, for example
         %* translates to (.*?) in PCRE unless the %* is found at the start or
         end of the line, in which cases it translates to (.*). Paranthesis in
         PCRE causes a change in execution priority similar to mathematical
         expressions, but paranthesis also causes the match to be stored to a
         variable.

         When nesting multiple sets of paranthesis each nest is assigned its
         numercial variable in order of appearance.

Example: #act {%* chats '{Mu(ha)+}'} {chat %2ha!}

         If someone chats Muha you will chat Muhaha! If someone chats Muhaha
         you will chat Muhahaha!

         </span><span class='l37'>Lazy vs Greedy</span><span class='d37'>

         By default regex matches are greedy, meaning {.*} will capture as much
         text as possible.

Example: #regex {bli bla blo} {^{.*} {.*}&dollar;} {#showme Arg1=(&amp;1) Arg2=(&amp;2)}

         This will display: Arg1=(bli bla) Arg2=(blo)

         By appending a ? behind a regex it becomes lazy, meaning {.*?} will
         capture as little text as possible.

Example: #regex {bli bla blo} {^{.*?} {.*?}&dollar;} {#showme Arg1=(&amp;1) Arg2=(&amp;2)}

         This will display: Arg1=(bli) Arg2=(bla blo).

         </span><span class='l37'>Escape Codes</span><span class='d37'>

         PCRE support the following escape codes.
</span><span class='l37'>
    PCRE Description                                    POSIX</span><span class='d37'>
      &bsol;A Match start of string                          ^
      &bsol;b Match word boundaries                          (^|&bsol;r|&bsol;n|&bsol;t| |&dollar;)
      &bsol;B Match non-word boundaries                      [^&bsol;r&bsol;n&bsol;t ]
      &bsol;c Insert control character                       &bsol;c
      &bsol;d Match digits                                   [0-9]
      &bsol;D Match non-digits                               [^0-9]
      &bsol;e Insert escape character                        &bsol;e
      &bsol;f Insert form feed character                     &bsol;f
      &bsol;n Insert line feed character                     &bsol;n
      &bsol;r Insert carriage return character               &bsol;r
      &bsol;s Match spaces                                   [&bsol;r&bsol;n&bsol;t ]
      &bsol;S Match non-spaces                               [^&bsol;r&bsol;n&bsol;t ]
      &bsol;t Insert tab character                           &bsol;t
      &bsol;w Match letters, numbers, and underscores        [A-Za-z0-9_]
      &bsol;W Match non-letters, numbers, and underscores    [^A-Za-z0-9_]
      &bsol;x Insert hex character                           &bsol;x
      &bsol;Z Match end of string                            &dollar;

         &bsol;s matches one space, &bsol;s+ matches one or multiple spaces.

         </span><span class='l37'>Color triggers</span><span class='d37'>

         To make matching easier text triggers (Actions, Gags, Highlights,
         Prompts, and Substitutes) have their color codes stripped. If you
         want to create a color trigger you must start the triggers with a ~
         (tilda). To make escape codes visible use #config {convert meta} on.

Example: #action {~&bsol;e[1;37m%1} {#var roomname %1}

         If the room name is the only line on the mud in bright white this
         color trigger will save the roomname.


         This covers the basics. PCRE has more options, most of which are
         somewhat obscure, so you'll have to read a PCRE manual for additional
         information.

</span><span class='l37'>Related</span><span class='d37'>: map and path.
<a name='PORT'></a>

</span><span class='l32'>         PORT

</span><span class='l37'>Command</span><span class='d37'>: #port </span><span class='l37'>{</span><span class='d37'>option</span><span class='l37'>} {</span><span class='d37'>argument</span><span class='l37'>}</span><span class='d37'>

         </span><span class='l37'>#port {init} {name} {port} {file}
         </span><span class='d37'>  Initilize a port session.

         </span><span class='l37'>#port {call} {address} {port}
         </span><span class='d37'>  Connect to a remote socket.

         </span><span class='l37'>#port {color} {color names}
         </span><span class='d37'>  Set the default color of port messages.

         </span><span class='l37'>#port {dnd}
         </span><span class='d37'>  Do Not Disturb. Decline new connections

         </span><span class='l37'>#port {group} {name} {group}
         </span><span class='d37'>  Assign a socket group.

         </span><span class='l37'>#port {ignore} {name}
         </span><span class='d37'>  Ignore a socket

         </span><span class='l37'>#port {info}
         </span><span class='d37'>  Display information about the port session.

         </span><span class='l37'>#port {name} {name}
         </span><span class='d37'>  Change socket name.

         </span><span class='l37'>#port {prefix} {text}
         </span><span class='d37'>  Set prefix before each message.

         </span><span class='l37'>#port {send} {name|all} {text}
         </span><span class='d37'>  Send data to socket

         </span><span class='l37'>#port {uninitialize}
         </span><span class='d37'>  Unitialize the port session.

         </span><span class='l37'>#port {who}
         </span><span class='d37'>  Show all connections

         </span><span class='l37'>#port {zap} {name}
         </span><span class='d37'>  Close a connection

         The port command is very similar to chat except that it creates a
         new session dedicated to receiving socket connections at the given
         port number without built-in support for a communication protocol.

</span><span class='l37'>Related</span><span class='d37'>: all, chat, run, session, sessionname, snoop, ssl and zap.
<a name='PROMPT'></a>

</span><span class='l32'>         PROMPT

</span><span class='l37'>Command</span><span class='d37'>: #prompt </span><span class='l37'>{</span><span class='d37'>text</span><span class='l37'>} {</span><span class='d37'>new text</span><span class='l37'>} {</span><span class='d37'>row #</span><span class='l37'>} {</span><span class='d37'>col #</span><span class='l37'>}</span><span class='d37'>

         Prompt is a feature for split window mode, which will capture a line
         received from the server and display it on the status bar of your
         split screen terminal. You would define &lt;text&gt; and &lt;new text&gt; the
         same way as with a substitution.

         The row number is optional and useful if you use a non standard split
         mode. A positive row number draws #row lines from the top while a
         negative number draws #row lines from the bottom. Without an argument
         #prompt will write to the default split line, which is at row -2.

         The col number is optional and can be used to set the column index.
         A positive col number draws the given number of columns from the left,
         while a negative col number draws from the right. If you leave the
         column argument empty tintin will clear the row before printing at
         the start of the row.

         The #showme command takes a row and col argument as well so it's also
         possible to place text on your split lines using #showme.

</span><span class='l37'>Comment</span><span class='d37'>: See </span><span class='l37'>#help split</span><span class='d37'> for more information on split mode.

</span><span class='l37'>Comment</span><span class='d37'>: See </span><span class='l37'>#help substitute</span><span class='d37'> for more information on text
         substitutions.

</span><span class='l37'>Comment</span><span class='d37'>: You can remove a prompt with the #unprompt command.

</span><span class='l37'>Related</span><span class='d37'>: action, gag, highlight and substitute.
<a name='READ'></a>

</span><span class='l32'>         READ

</span><span class='l37'>Command</span><span class='d37'>: #read </span><span class='l37'>{</span><span class='d37'>filename</span><span class='l37'>}</span><span class='d37'>

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

         If you uses braces, { and } you can use several lines for 1 commands.
         This however means you must always match every { with a } for the read
         command to work.

         You can comment out triggers using /* text */

</span><span class='l37'>Related</span><span class='d37'>: log, scan, textin and write.
<a name='REGEXP'></a>

</span><span class='l32'>         REGEXP

</span><span class='l37'>Command</span><span class='d37'>: #regexp </span><span class='l37'>{</span><span class='d37'>string</span><span class='l37'>} {</span><span class='d37'>expression</span><span class='l37'>} {</span><span class='d37'>true</span><span class='l37'>} {</span><span class='d37'>false</span><span class='l37'>}</span><span class='d37'>

         Compares the string to the given regular expression.

         Variables are stored in &amp;1 to &amp;99 with &amp;0 holding the matched substring.

       ^ force match of start of line.
       &dollar; force match of end of line.
       &bsol; escape one character.
  %1-%99 lazy match of any text, available at %1-%99.
      %0 should be avoided in triggers, and if left alone lists all matches.
     { } embed a raw regular expression, matches are stored to %1-%99.
   %!{ } embed a raw regular expression, matches are not stored.
         [ ] . + | ( ) ? * are treated as normal text unlessed used within
         braces. Keep in mind that { } is replaced with ( ) automatically
         unless %!{ } is used.

         Of the following the (lazy) match is available at %1-%99 + 1

      %w match zero to any number of word characters.
      %W match zero to any number of non word characters.
      %d match zero to any number of digits.
      %D match zero to any number of non digits.
      %s match zero to any number of spaces.
      %S match zero to any number of non spaces.

      %? match zero or one character.
      %. match one character. (</span><span class='l31'>do not use</span><span class='d37'>)
      %+ match one to any number of characters. (</span><span class='l31'>do not use</span><span class='d37'>)
      %* match zero to any number of characters.

      %i matching becomes case insensitive.
      %I matching becomes case sensitive (default).

         The match is automatically stored to a value between %1 and %99
         starting at %1 and incrementing by 1 for every regex. If you use
         %15 as a regular expression, the next unnumbered regular expression
         would be %16. To prevent a match from being stored use %!*, %!w, etc.

</span><span class='l37'>Example</span><span class='d37'>: #regexp {bli bla blo} {bli {.*} blo} {#showme &amp;1}

</span><span class='l37'>Related</span><span class='d37'>: case, default, else, elseif, if and switch.
<a name='REPEAT'></a>

</span><span class='l32'>         REPEAT

</span><span class='l37'>Command</span><span class='d37'>: #</span><span class='l37'>[</span></span><span class='b49'><span class='d37'>number</span><span class='l37'>] {</span><span class='d37'>commands</span><span class='l37'>}</span><span class='d37'>

Sometimes you want to repeat the same command multiple times. This is the
easiest way to accomplish that.

</span><span class='l37'>Example</span><span class='d37'>: #10 {buy bread}

</span><span class='l37'>Related</span><span class='d37'>: break, continue, foreach, list, loop, parse, return and while.
<a name='REPLACE'></a>

</span><span class='l32'>         REPLACE

</span><span class='l37'>Command</span><span class='d37'>: #replace </span><span class='l37'>{</span><span class='d37'>variable</span><span class='l37'>} {</span><span class='d37'>oldtext</span><span class='l37'>} {</span><span class='d37'>newtext</span><span class='l37'>}</span><span class='d37'>

         Searches the variable text replacing each occurance of 'oldtext' with
         'newtext'.

</span><span class='l37'>Related</span><span class='d37'>: format, function, local, math, script and variable.
<a name='RETURN'></a>

</span><span class='l32'>         RETURN

</span><span class='l37'>Command</span><span class='d37'>: #return </span><span class='l37'>{</span><span class='d37'>text</span><span class='l37'>}</span><span class='d37'>

         This command can be used to break out of a command string being
         executed.

         If used inside a #function you can use #return with an argument to both
         break out of the function and set the result variable.

</span><span class='l37'>Related</span><span class='d37'>: break, continue, foreach, list, loop, parse, repeat and while.
<a name='RUN'></a>

</span><span class='l32'>         RUN

</span><span class='l37'>Command</span><span class='d37'>: #run </span><span class='l37'>{</span><span class='d37'>name</span><span class='l37'>} {</span><span class='d37'>shell command</span><span class='l37'>} {</span><span class='d37'>file</span><span class='l37'>}</span><span class='d37'>

         The run command works much like the system command except that it
         runs the command in a pseudo terminal. The run command also creates
         a session that treats the given shell command as a mud server. This
         allows you to run ssh, as well as any other shell application, with
         full tintin scripting capabilities. If a file name is given the file
         is loaded prior to execution.

</span><span class='l37'>Example</span><span class='d37'>: #run {somewhere} {ssh someone@somewhere.com}
</span><span class='l37'>Example</span><span class='d37'>: #run {something} {tail -f chats.log}

</span><span class='l37'>Related</span><span class='d37'>: all, port, session, sessionname, snoop, ssl and zap.
<a name='SCAN'></a>

</span><span class='l32'>         SCAN

</span><span class='l37'>Command</span><span class='d37'>: #scan </span><span class='l37'>{</span><span class='d37'>abort</span><span class='l37'>|</span><span class='d37'>csv</span><span class='l37'>|</span><span class='d37'>tsv</span><span class='l37'>|</span><span class='d37'>txt</span><span class='l37'>} {</span><span class='d37'>filename</span><span class='l37'>}</span><span class='d37'>

         The scan command is a file loading utility.

         </span><span class='l37'>#scan {abort}
         </span><span class='d37'>  This command must be called from with a SCAN event and will
           abort the scan if one is in progress.

         </span><span class='l37'>#scan {csv} &lt;filename&gt;
         </span><span class='d37'>  The scan csv command reads in a comma separated value file
           without printing the content to the screen. Instead it triggers one
           of two events.

           The SCAN CSV HEADER event is triggered on the first line of the csv
           file. The SCAN CSV LINE event is triggered on the second and each
           subsequent line of the csv file. The %0 argument contains the entire
           line, with  %1 containing the first value, %2 the second value, etc,
           all the way up to %99.

           Values containing spaces must be surrounded with quotes, keep in mind
           newlines within quotes are not supported. Use two quotes to print one
           literal quote character.

         </span><span class='l37'>#scan {tsv} &lt;filename&gt;

         </span><span class='d37'>  The scan tsv &lt;filename&gt; command reads in a tab separated value file
           without printing the content to the screen. Instead it triggers the
           SCAN TSV HEADER event for the first line and SCAN TSV LINE for all
           subsequent lines.

         </span><span class='l37'>#scan {file} &lt;filename&gt; {commands}

         </span><span class='d37'>  The scan file command reads the given files and executes the
            commands argument. &amp;0 contains the raw content of the file and
            &amp;1 contains the plain content. &amp;2 contains the raw byte size of the
            file and &amp;3 the plain byte size. &amp;5 contains the line count.

         </span><span class='l37'>#scan {txt} &lt;filename&gt;

         </span><span class='d37'>  The scan txt &lt;filename&gt; command reads in a file and sends its content
           to the screen as if it was send by a mud. After using scan you can
           use page-up and down to view the file.

           This command is useful to convert ansi color files to html or viewing
           raw log files.

           Actions, highlights, and substitutions will trigger as normal, and it
           is possible to create an action to execute #scan abort to prematurely
           stop the scan.

</span><span class='l37'>Related</span><span class='d37'>: read and textin.
<a name='SCREEN'></a>

</span><span class='l32'>         SCREEN

</span><span class='l37'>Command</span><span class='d37'>: #screen </span><span class='l37'>{</span><span class='d37'>option</span><span class='l37'>} {</span><span class='d37'>argument</span><span class='l37'>}

         </span><span class='d37'>The screen command offers a variety of screen manipulation
         commands and utilities.

         </span><span class='l37'>#screen blur
         </span><span class='d37'>  Move the terminal to the back of the stack.

         </span><span class='l37'>#screen clear [all|scroll region|square] &lt;args&gt;
         </span><span class='d37'>  Provide 4 arguments defining the top left and bottom right corner
           when erasing a square.

         </span><span class='l37'>#screen focus
         </span><span class='d37'>  Move the terminal to the front of the stack.

         </span><span class='l37'>#screen fullscreen [on|off]
         </span><span class='d37'>  Toggles fullscreen mode when used without an argument.

         </span><span class='l37'>#screen get &lt;rows|cols|height|width&gt; &lt;var&gt;
         </span><span class='d37'>  Get the rows/cols size in characters or height/width in pixels.

         </span><span class='l37'>#screen get &lt;top_row|bot_row|top_split|bot_split&gt; &lt;var&gt;
         </span><span class='d37'>  Get the top and bot row of the scrolling region or the height
           of the top and bot split bars.

         </span><span class='l37'>#screen info
         </span><span class='d37'>  Debugging information.

         </span><span class='l37'>#screen load &lt;both|label|title&gt;
         </span><span class='d37'>  Reload the saved title, label, or both.

         </span><span class='l37'>#screen minimize &lt;on|off&gt;
         </span><span class='d37'>  Minimize with on, restore with off.

         </span><span class='l37'>#screen maximize [on|off]
         </span><span class='d37'>  Maximize with on, restore with off.

         </span><span class='l37'>#screen move &lt;height&gt; &lt;width&gt;
         </span><span class='d37'>  Move the upper left corner of the terminal to pixel coordinate.

         </span><span class='l37'>#screen raise &lt;event&gt;
         </span><span class='d37'>  This will raise several screen events with %1 and %2 arguments.

         </span><span class='l37'>#screen refresh
         </span><span class='d37'>  Terminal dependant, may do nothing.

         </span><span class='l37'>#screen rescale &lt;height&gt; &lt;width&gt;
         </span><span class='d37'>  Resize the screen to the given height and width in pixels.

         </span><span class='l37'>#screen resize &lt;rows&gt; &lt;cols&gt;
         </span><span class='d37'>  Resize the screen to the given height and width in characters.

         </span><span class='l37'>#screen save &lt;both|label|title&gt;
         </span><span class='d37'>  Save the title, label, or both.

         </span><span class='l37'>#screen set &lt;both|label|title&gt;
         </span><span class='d37'>  Set the title, label, or both. Only title works on Windows.

</span><span class='l37'>Related</span><span class='d37'>: bell
<a name='SCREEN READER'></a>

</span><span class='l32'>         SCREEN READER

</span><span class='l37'>Command</span><span class='d37'>: #config </span><span class='l37'>{</span><span class='d37'>SCREEN READER</span><span class='l37'>} {</span><span class='d37'>ON|OFF</span><span class='l37'>}</span><span class='d37'>

         Screen reader mode is enabled by using #config screen on. The main
         purpose of the screen reader mode is to tell MUDs that a screen reader
         is being used by using the MTTS standard. The MTTS specification is
         available at:

         http://tintin.sourceforge.net/protocols/mtts

         With the screen reader mode enabled TinTin++ will try to remove visual
         elements where possible.

</span><span class='l37'>Related</span><span class='d37'>: config
<a name='SCRIPT'></a>

</span><span class='l32'>         SCRIPT

</span><span class='l37'>Command</span><span class='d37'>: #script </span><span class='l37'>{</span><span class='d37'>variable</span><span class='l37'>} {</span><span class='d37'>shell command</span><span class='l37'>}</span><span class='d37'>

         The script command works much like the system command except that it
         treats the generated echos as commands if no variable is provided.

         This is useful for running php, perl, ruby, and python scripts. You
         can run these scrips either from file or from within tintin if the
         scripting language allows this.

         If you provide a variable the output of the script is stored as a list.

</span><span class='l37'>Example</span><span class='d37'>: #script {ruby -e 'print &quot;#showme hello world&quot;'}
</span><span class='l37'>Example</span><span class='d37'>: #script {python -c 'print &quot;#showme hello world&quot;'}
</span><span class='l37'>Example</span><span class='d37'>: #script {php -r 'echo &quot;#showme hello world&quot;'}
</span><span class='l37'>Example</span><span class='d37'>: #script {path} {pwd};#showme The path is &dollar;path[1].

</span><span class='l37'>Related</span><span class='d37'>: format, function, local, math, replace and variable.
<a name='SEND'></a>

</span><span class='l32'>         SEND

</span><span class='l37'>Command</span><span class='d37'>: #send </span><span class='l37'>{</span><span class='d37'>text</span><span class='l37'>}</span><span class='d37'>

         Sends the text directly to the MUD, useful if you want to start with an
         escape code.

</span><span class='l37'>Related</span><span class='d37'>: textin
<a name='SESSION'></a>

</span><span class='l32'>         SESSION

</span><span class='l37'>Command</span><span class='d37'>: #session </span><span class='l37'>{</span><span class='d37'>name</span><span class='l37'>} {</span><span class='d37'>host</span><span class='l37'>} {</span><span class='d37'>port</span><span class='l37'>} {</span><span class='d37'>file</span><span class='l37'>}</span><span class='d37'>

         Starts a telnet session with the given name, host, port, and optional
         file name. The name can be anything you want, except the name of an
         already existant session, a number, or the keywords '+', '-' and 'self'.

         If a file name is given the file is only read if the session succesfully
         connects.

         Without an argument #session shows the currently defined sessions.

         If you have more than one session, you can use the following commands:

         #session {-}        Switch to the previous session.
         #session {+}        Switch to the next session.
         #session {&lt;number&gt;} Switch to the given session. Session 0 is the
                             startup session, +1 the first, +2 the second, and
                             -1 is the last session. Sessions are (currently)
                             sorted in order of creation.
         #gts                Switch to the startup session. The name gts stands
                             for global tintin session.
         #ats                Switch to the active session. The name ats stands
                             for active tintin session.
                             not necessarily the calling session.
         #{name}             Activates to the session with the given name.
         #{name} {command}:  Executes a command with the given session without
                             changing the active session.
         @&lt;name&gt;{text}:      Parse text in the given session, substituting the
                             variables and functions, and print the result in
                             the current active session.

         The startup session is named 'gts' and can be used for relog scripts. Do
         keep in mind that tickers do not work in the startup session.

</span><span class='l37'>Example</span><span class='d37'>: #event {SESSION DISCONNECTED} {#gts #delay 10 #ses %0 mymud.com 4321}

</span><span class='l37'>Related</span><span class='d37'>: all, port, run, sessionname, snoop, ssl and zap.
<a name='SESSIONNAME'></a>

</span><span class='l32'>         SESSIONNAME

</span><span class='l37'>Syntax</span><span class='d37'>: #[sessionname] </span><span class='l37'>{</span><span class='d37'>commands</span><span class='l37'>}</span><span class='d37'>

You can create multiple sessions with the #session command. By default only one
session is active, meaning commands you input are executed in the active
session. While all sessions receive output, only output sent to the active
session is displayed.

When you create a session with the #session command you must specify a session
name, the session name, prepended with a hashtag, can be used to activate the
session when used without an argument. If an argument is given it will be
executed by that session as a command, the session will not be activated.

</span><span class='l37'>Example</span><span class='d37'>: #ses one mymud.com 23;#ses two mymud.com 23;#one;#two grin

This will create two sessions, the session that was created last (two in this
case) will be automatically activated upon creation. Using #one, session one is
activated. Using #two grin, the grin social will be executed by session two,
session one will remain the active session.

</span><span class='l37'>Related</span><span class='d37'>: all, port, run, session, snoop, ssl and zap.
<a name='SHOWME'></a>

</span><span class='l32'>         SHOWME

</span><span class='l37'>Command</span><span class='d37'>: #showme </span><span class='l37'>{</span><span class='d37'>string</span><span class='l37'>} {</span><span class='d37'>row</span><span class='l37'>} {</span><span class='d37'>col</span><span class='l37'>}</span><span class='d37'>

         Display the string to the terminal, do not send to the mud.  Useful for
         status, warnings, etc.  The {row} and col number are optional and work
         the same way as the row number of the #prompt trigger.

         Actions can be triggered by the showme command. If you want to avoid
         this from happening use: #line ignore #showme {&lt;string&gt;}.

</span><span class='l37'>Example</span><span class='d37'>: #tick {TICK} {#delay 50 #showme 10 SECONDS TO TICK!!!} {60}

</span><span class='l37'>Comment</span><span class='d37'>: The #prompt helpfile contains more information on using the
         option {row} and {col} arguments.

</span><span class='l37'>Related</span><span class='d37'>: buffer, draw, echo and grep.
<a name='SNOOP'></a>

</span><span class='l32'>         SNOOP

</span><span class='l37'>Command</span><span class='d37'>: #snoop </span><span class='l37'>{</span><span class='d37'>session name</span><span class='l37'>} {</span><span class='d37'>on</span><span class='l37'>|</span><span class='d37'>off</span><span class='l37'>}</span><span class='d37'>

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

         You can toggle off snoop mode by executing #snoop a second time.

</span><span class='l37'>Related</span><span class='d37'>: all, port, run, session, sessionname, ssl and zap.
<a name='SPEEDWALK'></a>

</span><span class='l32'>         SPEEDWALK

         </span><span class='d37'>Speedwalking allows you to type multiple directions not separated by
         semicolons, and now it lets you prefix a direction with a number, to
         signify how many times to go that direction. You can turn it on/off
         with #config.

</span><span class='l37'>Example</span><span class='d37'>: Without speedwalk, you have to type:
         s;s;w;w;w;w;w;s;s;s;w;w;w;n;n;w
         With speedwalk, you only have to type:
         2s5w3s3w2nw

</span><span class='l37'>Related</span><span class='d37'>: alias, cursor, history, keypad, macro and tab.
<a name='SPLIT'></a>

</span><span class='l32'>         SPLIT

</span><span class='l37'>Command</span><span class='d37'>: #split </span><span class='l37'>{</span><span class='d37'>top bar</span><span class='l37'>} {</span><span class='d37'>bottom bar</span><span class='l37'>}
Command</span><span class='d37'>: #split </span><span class='l37'>{</span><span class='d37'>&lt;square&gt;</span><span class='l37'>}

         This option requires for your terminal to support VT100 emulation.

         #split allows the creation of a top status bar, a scrolling region, a
         bottom status bar, and an input line.

         --top status bar--------

         </span><span class='d37'>  scrolling region

         </span><span class='l37'>--bottom status bar----------
         </span><span class='d37'>  input line

         By default the bottom status bar is filled with dashes --- and
         subsequently it is also known as the split line. The scrolling
         region is also known as the main screen and this is where all
         incoming text is displayed by default.

         If you use #split without an argument it will set the height of the
         top status bar to 0 lines and the bottom status bar to 1 line.

         If you use #split with one argument it will set the height of the top
         status bar to the given number of lines and the bottom status bar will
         be set to 1 line.

         If you use two arguments the first argument is the height of the top
         status bar and the second argument the height of the bottom status bar.

         The third and fourth argument are optional and tintin will interpret
         four arguments as a square argument existing of two coordinates
         defining the upper left corner and bottom right corner of the
         scrolling region.

</span><span class='l37'>Example</span><span class='d37'>: #split 0 0
         This will create a split screen with just a scrolling regino and an
         input line. Great for the minimalist.

</span><span class='l37'>Comment</span><span class='d37'>: You can display text on the split line(s) with the #prompt and
         #showme {line} {row} commands.

</span><span class='l37'>Comment</span><span class='d37'>: You can remove split mode with the #unsplit command.

</span><span class='l37'>Related</span><span class='d37'>: echo, prompt and showme.
<a name='SSL'></a>

</span><span class='l32'>         SSL

</span><span class='l37'>Command</span><span class='d37'>: #ssl </span><span class='l37'>{</span><span class='d37'>name</span><span class='l37'>} {</span><span class='d37'>host</span><span class='l37'>} {</span><span class='d37'>port</span><span class='l37'>} {</span><span class='d37'>file</span><span class='l37'>}

         Starts a secure socket telnet session with the given name, host, port,
         and optional file name.

Related</span><span class='d37'>: all, port, run, sessionname, snoop, ssl and zap.
<a name='STATEMENTS'></a>

</span><span class='l32'>         STATEMENTS

         TinTin++ knows the following statements.
</span><span class='d37'>
         #break
         #case {value} {true}
         #continue
         #default {commands}
         #else {commands}
         #elseif {expression} {true}
         #foreach {list} {variable} {commands}
         #if {expression} {true}
         #loop {min} {max} {variable} {commands}
         #parse {string} {variable} {commands}
         #return {value}
         #switch {expression} {commands}
         #while {expression} {commands}

</span><span class='l37'>Related</span><span class='d37'>: commands, help and info.
<a name='SUBSTITUTE'></a>

</span><span class='l32'>         SUBSTITUTE

</span><span class='l37'>Command</span><span class='d37'>: #substitute </span><span class='l37'>{</span><span class='d37'>text</span><span class='l37'>} {</span><span class='d37'>new text</span><span class='l37'>}</span><span class='d37'>

         Allows you to replace original text from the mud with different text.
         This is helpful for complex coloring and making things more readable.
         The %1-%99 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 only one argument is given, all active substitutions that match the
         strings are displayed.  The '%*' char is valid in this instance.  See
         '#help regex', for advanced wildcard information.

         If no argument is given, all subs are displayed.

</span><span class='l37'>Example</span><span class='d37'>: #sub {Zoe} {ZOE}
         Any instance of Zoe will be replaced with ZOE.

</span><span class='l37'>Example</span><span class='d37'>: #sub {~&bsol;e[0;34m} {&bsol;e[1;34m}
         Replace generic dark blue color codes with bright blue ones.

</span><span class='l37'>Example</span><span class='d37'>: #sub {%1massacres%2} {&lt;018&gt;%1&lt;118&gt;MASSACRES&lt;018&gt;%2}
         Replaces all occurrences of 'massacres' with 'MASSACRES' in red.

</span><span class='l37'>Comment</span><span class='d37'>: See '#help action', for more information about triggers.

</span><span class='l37'>Comment</span><span class='d37'>: See '#help colors', for more information.

</span><span class='l37'>Comment</span><span class='d37'>: You can remove a substitution with the #unsubstitute command.

</span><span class='l37'>Related</span><span class='d37'>: action, gag, highlight and prompt.
<a name='SUSPEND'></a>

</span><span class='l32'>         SUSPEND

</span><span class='l37'>Command</span><span class='d37'>: #cursor suspend

         Temporarily suspends tintin and returns you to your shell.  To
         return to tintin, type 'fg' at the shell prompt.

         While suspended your tintin sessions will freeze. To keep a
         suspended session running use the #detach command.

</span><span class='l37'>Related</span><span class='d37'>: end
<a name='SWITCH'></a>

</span><span class='l32'>         SWITCH

</span><span class='l37'>Command</span><span class='d37'>: #switch </span><span class='l37'>{</span><span class='d37'>conditional</span><span class='l37'>} {</span><span class='d37'>arguments</span><span class='l37'>}</span><span class='d37'>

         The switch command works similar to the switch statement in other
         languages. When the 'switch' command is encountered its body is parsed
         and each 'case' command found will be compared to the conditional
         argument of the switch and executed if there is a match.

         When comparing strings the switch and case arguments must be enclosed
         in quote characters.

         If the 'default' command is found and no 'case' statement has been
         matched the default command's argument is executed.

</span><span class='l37'>Example</span><span class='d37'>: #switch {1d4} {#case 1 cackle;#case 2 smile;#default giggle}

</span><span class='l37'>Related</span><span class='d37'>: statements
<a name='SYSTEM'></a>

</span><span class='l32'>         SYSTEM

</span><span class='l37'>Command</span><span class='d37'>: #system </span><span class='l37'>{</span><span class='d37'>command</span><span class='l37'>}</span><span class='d37'>

         Executes the command specified as a shell command.

</span><span class='l37'>Related</span><span class='d37'>: detach, script and run.
<a name='TAB'></a>

</span><span class='l32'>         TAB

</span><span class='l37'>Command</span><span class='d37'>: #tab </span><span class='l37'>{</span><span class='d37'>word</span><span class='l37'>}</span><span class='d37'>

         Adds a word to the tab completion list, alphabetically sorted.

         If no tabs are defined tintin will use the scrollback buffer
         for auto tab completion.

</span><span class='l37'>Comment</span><span class='d37'>: You can remove a tab with the #untab command.

</span><span class='l37'>Related</span><span class='d37'>: alias, cursor, history, keypad, macro and speedwalk.
<a name='TEXTIN'></a>

</span><span class='l32'>         TEXTIN

</span><span class='l37'>Command</span><span class='d37'>: #textin </span><span class='l37'>{</span><span class='d37'>filename</span><span class='l37'>} {</span><span class='d37'>delay</span><span class='l37'>}</span><span class='d37'>

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

         The delay is in seconds and takes a floating point number which is
         cumulatively applied to each outgoing line.

</span><span class='l37'>Related</span><span class='d37'>: scan and send.
<a name='TICKER'></a>

</span><span class='l32'>         TICKER

</span><span class='l37'>Command</span><span class='d37'>: #ticker </span><span class='l37'>{</span><span class='d37'>name</span><span class='l37'>} {</span><span class='d37'>commands</span><span class='l37'>} {</span><span class='d37'>interval in seconds</span><span class='l37'>}</span><span class='d37'>

         Executes given command every # of seconds.

</span><span class='l37'>Comment</span><span class='d37'>: Tickers don't work in the startup session.

</span><span class='l37'>Comment</span><span class='d37'>: You can remove a ticker with the #unticker command.

</span><span class='l37'>Related</span><span class='d37'>: delay and event.
<a name='TIME'></a>

</span><span class='l32'>         TIME

</span><span class='l37'>Command</span><span class='d37'>: #format </span><span class='l37'>{</span><span class='d37'>variable</span><span class='l37'>} {</span><span class='d37'>%t</span><span class='l37'>} {</span><span class='d37'>argument</span><span class='l37'>}</span><span class='d37'>

         The %t format specifier of the #format command allows printing dates
         using the strftime() format specifiers. By default the time stamp used
         is the current time, if you want to print a past or future date use:

</span><span class='l37'>Command</span><span class='d37'>: #format </span><span class='l37'>{</span><span class='d37'>variable</span><span class='l37'>} {</span><span class='d37'>%t</span><span class='l37'>} {{</span><span class='d37'>argument</span><span class='l37'>} {{</span><span class='d37'>epoch time</span><span class='l37'>}}</span><span class='d37'>

         The current epoch time value is obtained using #format {time} {%T}.

         When using %t the argument should contain strftime format specifiers.
         The output may differ depending on your locale.

         %a  Abbreviated name of the day of the week (mon ... sun).
         %A  Full name of the day of the week. (Monday ... Sunday)
         %b  Abbreviated name of the month (Jan ... Dec)
         %B  Full name of the month. (January ... December)
         %C  2 digit numeric century. (19 ... 20)
         %d  2 digit numeric day of the month (01 ... 31)
         %H  2 digit numeric 24-hour clock hour. (00 ... 23)
         %I  2 digit numeric 12-hour clock hour. (01 ... 12)
         %j  3 digit numeric day of the year (001 ... 366)
         %m  2 digit numeric month of the year (01 ... 12)
         %M  2 digit numeric minute of the hour (00 ... 59)
         %p  Abbreviated 12 hour clock period (AM ... PM)
         %P  Abbreviated 12 hour clock period (am ... pm)
         %S  2 digit numeric second of the minute (00 ...59
         %u  1 digit numeric day of the week (1 ... 7)
         %U  2 digit numeric Sunday week of the year (00 ... 53
         %w  1 digit numeric day of the week (0 ... 6)
         %W  2 digit numeric Monday week of the year (00 ... 53
         %y  2 digit numeric year. (70 ... 38)
         %Y  4 digit numeric year. (1970 ... 2038)
         %z  5 digit timezone offset. (-1200 ... +1400)
         %Z  Abbreviated name of the time zone.

</span><span class='l37'>Related</span><span class='d37'>: echo and format.
<a name='VARIABLE'></a>

</span><span class='l32'>         VARIABLE

</span><span class='l37'>Command</span><span class='d37'>: #variable </span><span class='l37'>{</span><span class='d37'>variable name</span><span class='l37'>} {</span><span class='d37'>text to fill variable</span><span class='l37'>}</span><span class='d37'>

         Variables differ from the %0-99 arguments in the fact that you can
         specify a full word as a variable, and they stay in memory for the
         full session unless they are changed.  They can be saved in the
         coms file, and can be set to different values if you have two or
         more sessions running at the same time.  Variables are global for
         each session and can be accessed by adding a &dollar; before the variable
         name.

</span><span class='l37'>Example</span><span class='d37'>: #alias {target} {#var target %0}
         #alias {x}      {kick &dollar;target}

         The name of a variable must exist of only letters, numbers and
         underscores in order to be substituted.  If you do not meet these
         requirements do not panic, simply encapsulate the variable in braces:

</span><span class='l37'>Example</span><span class='d37'>: #variable {cool website} {http://tintin.sourceforge.net}
         #chat I was on &dollar;{cool website} yesterday!.

         Variables can be nested using brackets or dots:

</span><span class='l37'>Example</span><span class='d37'>: #var hp[self] 34;#var hp[target] 46

         You can see the first nest of a variable using &dollar;variable[+1] and the
         last nest using &dollar;variable[-1]. Using &dollar;variable[-2] will report the
         second last variable, and so on. To show all indices use &dollar;variable[].
         To show all values use &dollar;variable[%*] or a less generic regex.

         Nested variables are also known as tables, table generally being used
         to refer to several variables nested within one specific variable.

</span><span class='l37'>Example</span><span class='d37'>: #showme {Targets starting with the letter A: &dollar;targets[A%*]

         To see the internal index of a variable use &amp;&lt;variable name&gt;. To see
         the size of a table you would use: &amp;targets[] or &amp;targets[%*]. A non
         existent nested variable will report itself as 0.

</span><span class='l37'>Example</span><span class='d37'>: #showme {Number of targets starting with A: &amp;targets[A%*]

         In some scripts you need to know the name of a nested variable. This
         is also known as the key, and you can get it using *variable. For
         example *target[+1]. To get the first variable's name use *{+1}.

         It's also possible to declare a table using brace notation. Using
         #var hp[self] 34 is the equivalent of #var {hp} {{self}{34}}. This
         also allows merging tables. #var hp[self] 34;#var hp[target] 46 is
         the equivalent of #var {hp} {{self}{34} {target}{46}} as well as
         #var {hp} {{self}{34}} {{target}{46}} or if you want to get creative
         the equivalent of #var hp[self] 34;#var {hp} {&dollar;hp} {{target}{46}}.

</span><span class='l37'>Comment</span><span class='d37'>: You can remove a variable with the #unvariable command.

</span><span class='l37'>Related</span><span class='d37'>: format, function, local, math, replace and script.
<a name='WHILE'></a>

</span><span class='l32'>         WHILE

</span><span class='l37'>Command</span><span class='d37'>: #while </span><span class='l37'>{</span><span class='d37'>conditional</span><span class='l37'>} {</span><span class='d37'>commands</span><span class='l37'>}</span><span class='d37'>

         This command works similar to a 'while' statement in other languages.

         When a 'while' command is encourated, the conditional is evaluated,
         and if TRUE (any non-zero result) the commands are executed. The
         'while' loop will be repeated indefinitely until the conditional is
         FALSE or the #BREAK or #RETURN commands are found.

         The 'while' statement is only evaluated if it is read, so you must
         nest it inside a trigger, like an alias or action.

         The conditional is evaluated exactly the same as in the 'math' command.

</span><span class='l37'>Example</span><span class='d37'>: #math cnt 0;#while {&dollar;cnt &lt; 20} {#math cnt &dollar;cnt + 1;say &dollar;cnt}

</span><span class='l37'>Comment</span><span class='d37'>: See '#help math', for more information.

</span><span class='l37'>Related</span><span class='d37'>: statements
<a name='WRITE'></a>

</span><span class='l32'>         WRITE

</span><span class='l37'>Command</span><span class='d37'>: #write </span><span class='l37'>{</span><span class='d37'>&lt;filename&gt;</span><span class='l37'>} {</span><span class='d37'>[FORCE]</span><span class='l37'>}</span><span class='d37'>

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

         By default you cannot write to .map files to prevent accidentally
         overwriting a map file. Use the FORCE argument to ignore this
         protection.

</span><span class='l37'>Related</span><span class='d37'>: log, read, scan and textin.
<a name='ZAP'></a>

</span><span class='l32'>         ZAP

</span><span class='l37'>Command</span><span class='d37'>: #zap {[session]}

         Kill your current session.  If there is no current session, it will
         cause the program to terminate. If you provide an argument it'll zap
         the given session instead.

</span><span class='l37'>Related</span><span class='d37'>: all, port, run, session, sessionname, snoop and ssl.