WinTin TinTin Guide

# **WinTin or TinTin**

WinTin\*\* is a free telnet client (which I detailed in the Beginners Guide.) that can enhance your playing experience by expanding upon the basic features of Telnet. With it you can make triggers, aliases, and a whole lot more. This page will describe a few ways in which you can tinker with WinTin in order to get the most out of your client.

TinTin++ is the Linux/Mac version and can be downloaded. The scripts work the same.

Almost every other client also has the same general abilities, though the actual commands you type in are usually quite different. WinTin (or it's command line version, tintin) used to be one of the most popular clients, but easier-to-use ones like zMUD, GMUD, CMUD, etc. gradually overtook it and now WinTin is used by a much smaller proportion of the MUDding world. WinTin also fits nicely onto a USB flash drive.

## **Getting WinTin or TinTin**

Download WinTin  and install.
Download TinTin  for Linux/Mac . The scripts work the same.

## **Basic Setup**

Change your font size and colors. (I almost always use font courier size 11, silver color, with a black background. Easy on the eyes! I also turn off the toolbar and status bar to get more window space.)

Note: The triggers below were all made with WinTin95, not the newer WinTin.net which uses the .net framework. So some things will work with the new version and some things won't. However, they are all backwards compatible.

**Aliases**

Now that you have everything installed and set up properly, let's make your very first #alias. An alias is a command you type that the client translates into a second command, so you can type your commands much faster than writing it all out. Our first alias will let you connect to the MUD with just typing three easy letters.

Normally you connect to MUDs with WinTin by typing #session <number> <address> <port>, in the normal pane where you type in text (should have a > and a blinking cursor). This can be fairly long and boring to type every time you want to connect! So type this in, before we're even connect to anything: #alias dsl #ses 1 dsl-mud.org 4000. Hurray! You've made your first #alias. Now you can log on: Just type DSL and you will be connected to the game. Woohoo!!

Note: WinTin has a feature called Speedwalking that lets you type things like 4e5es5d and it'll immediately make you run 4 east, 5 east again, 1 south, 5 down. This can be a problem because when you type sw to go southwest, it'll think you want to go south, then west because of speedwalking. To get around speedwalking there are many ways:

* You can turn it off. Type #speedwalk
* You can use capital letters (ie. SW).
* You can type out the entire name of the direction (ie. southwest).
* Or turn it into an alias by making the following aliases:

#alias sw southwest
#alias nw northwest
#alias se southeast
#alias ne northeast
Note though that using 3se will not be 3 southeast, it will still be 3 south, 1 east. But se, sw, alone will work properly. Also, this also means that if you want to check the 'news' it will think you are going north east south west-- so put it in caps instead. NEWS!

**Triggers**

Now let's make a trigger. A trigger is just like it sounds -- whenever a certain line of text scrolls by, the client will make you perform a certain list of actions. Creating triggers in WinTin is simple and I find WinTin's triggers much easier to make than any other MUD client.

Our first trigger will skip through that annoying 'Do you want color' and login thing at the start so you can go right to connecting with your character. Triggers use the #action command: the syntax is #action {<trigger>} {<actions to take, separated by semi-colons>}

So, for our first trigger, type this while you are connected to the MUD:

#action {^Do you want color? (Y/N)} {y;p;p}
What does this do, exactly? The ^ symbol at the beginning tells the trigger to only happen when the text (Do you want color?) is at the very beginning of a line -- so someone can't send you a tell with that text and make it kick in. The **Y;p;p** tells the client to answer Yes, then skip the Hit Return to Continue line and go right to P which is play an existing character.

Note - this will work if you are trying to play a character that is not yet on a master account.

You don't, in fact, need the squiggly brackets there - but if you don't, WinTin thinks the commas are separate commands rather than parts of the trigger. For example, if you type 'say hi;pmote dances.' then WinTin will run both commands, right after the other. You can disable this feature by hitting # by itself, which will turn off all WinTin parsing. Or, you can do like me, and if you need a semicolon in your text somewhere you can just put a \ in front of it. Like oclan I just killed Mantaroth!! \;) Otherwise it will think the ) is a command to come after the oclan and that'd just look silly.

**Simple Trigger**

*Example: Hungry/Thirsty -*

This is a very simple early trigger (called an #action in WinTin) that will simply try a few drinks from a decanter if you are carrying one in your inventory. It is extremely easy.

Just type this in the normal place where you type any command in:

#action {^You are hungry.} {drink decanter;drink decanter}
#action {^You are thirsty.} {drink decanter;drink decanter}
It obviously won't let you drink anything if you are sleeping, or don't have a decanter, but it's still handy to have and not that spammy if you only drink twice at a time. The ^ tells WinTin to only trigger it if it comes at the beginning of a line (so people can't trigger it by OOCing it for example).

## **Advanced Setup**

**Variables**

Some triggers can get quite complex -- WinTin has a very powerful trigger language and allows you to use all kinds of fun variables and things. The first advanced trigger we'll make is a stat roller -- this is a very simple trigger that will show you the total roll when you are rolling random stats in character creation. It also uses something called a #variable -- these are stored numbers that can be retrieved later for you when you want to look at them.

First off, type this in:

#var {total} {0}
This creates and sets to 0 our new 'total' variable, which we will need for later.

Then type in:

#action {^[Str: %0 Int: %1 Wis: %2 Dex: %3 Con: %4]} {#math {total} {%0+%1+%2+%3+%4}}
Those % things might be a bit odd, and the #math is a new type of function. I'll go over what the two do. First off, the %0, %1, and so on are what are called 'local variables' or 'temporary variables'. Essentially, these store information in a specific location which you defined in the first part of the action. They are not saved permanently the way a #variable is. The #math command is used to perform a simple math function and save the answer: the syntax is #math {variable to be saved} {math stuff}. For example, #math {stuff} {2+2} would save 4 in the variable 'stuff', which would be saved permanently until changed or wiped. It returns no text or info by itself, just saves the total. So, as you can see in our new #action, what it does is make a variable 'total' and adds up all our local variables. But it returns nothing! How do we view it?

WinTin has a special command called #showme that displays text on the screen -- this isn't shown to the MUD and is not a command that it makes you type in. Just displays it and that's it. For example, you could do #showme HI!!!! and it would show up on your screen but nobody else would ever see it but you. So we will use #showme to display the current total. We will trigger the showme to show after the #math is done-- it will trigger off the 'keep these stats?' instead because the #math has already calculated. Thus, make this trigger now:

#action {^Keep these stats? (Y/N)} {#showme Total: $total}
Now each time you hit N it will show you, above the next one, the total of the rolled stats. The '$total' in this case is how you display a saved, permanent variable: The $ is necessary. For example, if you logged in the game and typed '#math {total} {2+2}' and then 'say $total' you would say '4'.

**#if command**

The #if command allows you to make simple case statements that let you check for certain conditions within the trigger/alias/whatever itself. The actual syntax is this: #if {case statement} {action;action;action;etc}

For example, let's go back to our stat roller. It's pretty simple right now - just saves the target variable and spits it out later. Let's make it roll Y or N for us automatically if the total is under 250. First, we have our first trigger as usual to store the total:

#action {^[Str: %0 Int: %1 Wis: %2 Dex: %3 Con: %4]} {#math {total} {%0+%1+%2+%3+%4}}
Second, we alter the second trigger slightly:

#action {^Keep these stats? (Y/N)} {#if {$total<250} {n;#showme Total: $total};#if { $total>=250 } {y}}
Two #ifs! Remember, our syntax is this: #action {text} {action;action} -- in this case the actions are #ifs, which are #if { thing=true } {action}, so we have commands inside commands here. It may look a bit complex, but if you read it over carefully it's actually pretty simple.

So in our case, if the total is less than 250, it goes N and looks for the next one in a loop, if not then it says Yes and stops the loop for us. Convenient! Many triggers are exactly that -- built for convenience.

## **Loops**

Loops are fun. If you're out pkilling, you can make a loop to run to hit someone as soon as they walk in the room. You can do this with triggers, too, but sometimes people are sneaking so you can't see them as they pop in. This way, you can get the drop on someone very quickly.

This time, we'll be using a whole set of variables, triggers, and aliases. This one will be good practice for making your own.

Let's say you want a kick loop: this will repeat kicks each time, while you just sit back and watch.

First, make a variable so you can turn it on and off easily, and a set of aliases to turn the variable on or off:

#var {kicker} {0}
#alias {kickon} {#var {kicker} {1}}
#alias {kickoff} {#var {kicker} {0}}
So in-game when you type 'kickon' or 'kickoff' it'll simply change that variable to a 1 or a 0. Easy.

Next, make the actual trigger. The trigger itself will search for the string 'Your kick' because that's what all the kicks start with.

#action {^Your kick} {#if { $kicker=1 } {kick;#showme Kicking again!}}
That's it! That's your whole loop. Now if you're out and about and want to turn this loop on, just type: 'kickon', then when you're in combat, kick once. That will start the repeating loop and you'll keep kicking it until it dies or you flee (you'll get one They are not here! message and then it'll stop). In between kicks you can do stuff like check where, drink potions, or whatnot but you'll have one round of lag as it kicks again before your commands go through.

Let's try a more complex one -- this will run a loop waiting for a player to come by.

First off, we'll want a 'target' variable. This will store the person's name. You'll also want a looper variable to turn it on or off easily, and aliases to set all those properly.

#var {looper} {0}
#var {target} {0}
#alias {loopon} {#var {looper} {1}}
#alias {loopoff} {#var {looper} {0}}
alias {target} {#var {target} {%0}}
There! To set your new target, you'd use 'target <person>', to turn the whole thing on or off just hit loopon or loopoff, and to blank your target's name just use '0' or 'NULL' or something similar.

Next, you'll want the actual loop.
First, you'll want to find the 'They are not here!" message of the skill or spell you want to use. For spells it is They aren't here. and for skills it's usually something similar.
Then, trigger it:

#action {^They aren't here.} {#if { $looper=1 } {c 'sleep' $target}}
Simple. Of course, if you want to change your spell or skill, just replace c sleep with something like bash $target, trip $target, strangle $target, c acid $target, whatever.

If you want to be able to change the action part on the fly, add this too:

#var {loopaction} {c sleep}
#var {loopfail} {They aren't here.}
#alias {loopact} {#var {loopaction} {%0}}
#alias {loopfail} {#var {loopfail} {%0}}
#action {^$loopfail} {#if { $looper=1 } {$loopaction $target}}
Whew, that's a lot of aliases and stuff. Let's go over what it does. The first part way at the top turns on and off the loop itself, while typing target <name> will change who you are looking for. The #action bit is the string to check for -- since it checks on the fail message, each time you fail the spell it will loop again and cast the same thing. You can only end the loop using 'loopoff' which will stop the #action from triggering again.

The second part, with the 'loopfail' and 'loopaction' lets you customize the spell or skill you want to use on-the-fly. If you're out somewhere pkilling and type 'loopact bash' it would immediately make you want to start bashing whoever that person is. Might seem complicated at first, but it's actually fairly simple if you understand how loops and variables and stuff work.

## **Chasing Trigger**

Whee, this part is fun. It is also slightly long and complex, too. It works much like the previous example, but uses several triggers to scan for a player and immediately do an action to them. I'll go over each step first:

First, set up all your aliases and variables:

#var {kill} {0}
#alias {killon} {#var {kill} {1}}
#alias {killoff} {#var {kill} {0}}
#var {target} {0}
#alias {target} {#var {target} {%0}}
#var {chaseaction} {bash}
#alias {chaseact} {#var {chaseaction} {%0 $target}}
Second, set up your wad of triggers to look for $target:

#action {^$target flies %0.} {#if { $kill=1 } {%0;chaseaction}}
#action {^$target flies in.} {#if { $kill=1 } {chaseaction}}
#action {^$target floats %0.} {#if { $kill=1 } {%0;chaseaction}}
#action {^$target floats in.} {#if { $kill=1 } {chaseaction}}
#action {^$target has arrived.} {#if { $kill=1 } {chaseaction}}
#action {^$target leaves %0.} {#if { $kill=1 } {%0;chaseaction}}
#action {^$target runs %0.} {#if { $kill=1 } {%0;chaseaction}}
#action {^$target runs in.} {#if { $kill=1 } {chaseaction}}
#action {^$target walks %0.} {#if { $kill=1 } {%0;chaseaction}}
#action {^$target walks in.} {#if { $kill=1 } {chaseaction}}
#action {^$target, nearby to the %0.} {#if { $kill=1 } {%0;chaseaction}}
#action {^$target, not far %0.} {#if { $kill=1 } {%0;%0;chaseaction}}
#action {^$target, off in the distance %0.} {#if { $kill=1 } {%0;%0;%0;chaseaction}}
#action {^$target, right here} {#if { $kill=1 } {chaseaction}}
#action {^$target appears in the room.} {#if { $kill=1 } {chaseaction}}
There! That's all you need. To turn on your whole shebang use 'killon', to turn it off use 'killoff'. To change who you're hunting for, just type 'target <person>'. To change the action you want to take when you see this person nearby, use 'chaseact <action>'. When hunting them down, if you scan and see them nearby or see them walk in the room, it'll trigger instantly and do whatever to them.

Just don't blame me if these triggers make you run all over the place without you wanting to -- that's exactly what they're for. It's very easy to get confused if you're not used to using triggers to chase people-- frankly I actually prefer just spamming in the command a bajillion times and hitting ~ when it lands so the rest cancel. Could be why I suck so bad, though.

## **Other**

There are lots of other stuff you can do with WinTin, some of which don't involve triggers.

The first is a simple, easy \*\*tick-timer.\*\* WinTin comes with a built-in ticker, but you must have hours %t in your prompt somewhere for this to work, since due to lag and stuff the timer will eventually go off-kilter. Here's the easiest way:

#var {lasthour} {0}
#alias {ticker} {#ticksize 41;#tickon}
#act {^%0%1:00%2m%3} {#if { $lasthour=0 } {#var lasthour 1;#tickset}}
#act {^%0%1:30%2m%3} {#if { $lasthour=1 } {#var lasthour 0;#tickset}}
Your prompt must have %t, preferably in between some other stuff. The %0 and %3 in there are 'other stuff', meaning whatever comes before or after the hour. The %1:00%2m bits? that checks for x:00pm and saves the time difference as a 1 or a 0. This means that each time your prompt goes by the triggers will search for a :30 or a :00 in your prompt and if it's different than the last prompt that went by, that means a tick has gone by and it can reset your ticker to 41 seconds again.

Note: Whenever you login with a new character you will need to type 'ticker' to turn it on again. If you want to turn it off at any time, just log off or hit #tickoff

The ticker gives a +10 seconds message at 31 seconds to tick, a -10 seconds at 11 seconds to tick, and a #TICK! message during the actual tick itself. At -10 seconds you have about 3-4 combat rounds before the tick goes by -- great for checking your charmies for charm having worn off, sleeping exactly on the tick, etc.

**#gag**

Just hit #gag <text> and it'll completely wipe all traces of that text from showing it to you. For example it's great to gag things like the vampiric or flaming messages since those are very spammy and you already KNOW if your weapon is vampiric or flaming. If your gag is checked on any part of a line it will wipe the whole line -- ie if you do #gag Scorn, you will never see any line that has Scorn in it, including that one line of the WHO list and stuff like that. But you will still see the rest of the who list.

**#highlight**

With a #highlight you can display text in different colors as well as transfer text into other windows to browse later without spam. To highlight a block of text, use #highlight {<color>} {<text>}, where 'color' can be either a name or a number from 1-32.

*Example:. Try this: #high {red} {^The white aura around your body fades.}*

The second #highlight command is to create a new window for your tells, clantalk, gossips, ooc, etc. for you to read without spam in the way. The small side effect is that your normal messages on the main window will lose their color. I dunno why it does that. Anyway, just change the 'color' bit in #highlight to any number from #60 to #70 and it will make a whole new window for it. Use %0/%1/%n to make wild-cards for your text. I use:

#high {62} {^%0 OOC: %1}
#high {62} {^%0 tells you%1}
#high {62} {^%0 tells the group%1}
#high {62} {^You tell %0}
#high {62} {^%0 clans%1}
#high {62} {^%0 OOC clans%1}
#high {62} {^You OOC clan%1}
Note: Using these highlights will make a new window popup the first time they kick in, so you will need to switch back via ctrl-tab or clicking the window bar the first time. Also they have a bit of a problem scrolling down, but it's not a big deal. You'll see what I mean if you use it.

**#read and #write**

These are actually the most important commands in WinTin and I probably should have written them down first. Anyway, these are what you use to load and save your entire set of #aliases, #triggers, #variables, and so on. When you are finished writing one, type '#write dsl'. When you first boot up WinTin, type '#read dsl'.

Note: It will also save the current state of your #variables (including stuff like $target or your loops) so make sure all your variables and loops and stuff are turned off (set to 0) before you #write. Nothing is as unpleasant as logging on and forgetting all your stuff is still turned on.

You only need to #read once per session of WinTin, and you can do it before you even log on. #write is only used when you add new triggers and stuff to save it to text. (you can even edit this text directly by going to your wintin folder and editing the file 'dsl' in notepad).

**#zap**

This command is used to close wintin without having to actually click the X in the corner. If you do it while you are still connected to the game, you will drop link and go back to the regular unconnected WinTin window. If you hit #zap while NOT connected, it will close wintin entirely. This is also useful if you quit and it doesn't disconnnect you all the way, just sits at 'All good things must come to an end' or whatever.

**#**

When used by itself it completely turns off all the wintin-specific commands (such as #alias, #trigger, ; to seperate commands, speedwalking, etcetcetc). Hit it again to turn them all back on.

**#bell**

This is useful when you need to get your own attention and fast. It sends you a beep. Bing! Put it in triggers and stuff if you are doing stuff in another window or not really paying attention. Like.. #action {You may now quest again.} {#bell}

**#killall**

This command wipes all your current aliases, triggers, etc, such as if you are switching to a different MUD with a diffferent set of aliases, triggers and whatnot mid-game. Use #write dsl, #killall, #read newmud. All your stuff will be saved to the 'dsl' file so you can load it later. Otherwise you'd have to close wintin and log back on.

**<number>**

This command lets you loop a command <number> number of times. For example: #5 give egg Scorn will give me 5 eggs.

**#unaction, #unvar, #unalias**

These all let you delete a previously entered command of that type. The thing you're deleting must be spelled exactly. For example, #unaction {You may now quest again.} will wipe it entirely.

Have fun! I may also add more triggers in the future (I have some for stuff like being disarmed, for example), so check back frequently.

Go back to the DSL Wiki Home Page

Return to the  Top of the Page