Wintin 95 Help Index

Legal Notices

What Is Wintin 95?

Installing Wintin

Starting Wintin

Connecting to a Mud

Introduction to Commands

Tintin can damage you!

New in this release

William Lees

Wintin 95 Commands

action alias all antisubstitute bell boss
char cr echo end gag help
highlight history if ignore info killall
lists log loop map mark math
message nop openwin path pathdir presub
push read redraw remove retab return
rnd savepath select session showme snoop
sound speedwalk split substitute suspend system
tabadd tabdelete tablist textin tick tickoff
tickset ticksize tolower togglesubs toupper unaction
unalias unantisubstitute ungag unhighlight unpath unsplit
unsubstitute unvariable update variable verbatim version
wildcard wizlist write writesession zap

New in this release

Version 1.73

A fix to stop Wintin exiting when several sessions are active and one is closed. Many thanks to C L Wu for this fix.

A fix to tickset, which will make it work better when it's confined to a time window.

A larger Edit Definitions dialog, with word wrap on the definition itself.

No more Windows Help file! Sorry, but the format is just too ugly to work with. From now on, the help will be a standalone html document (the thing you are reading now). Mathew Mamet has agreed to maintain it, so look forward to some improvements.

Version 1.70

Mud Sound Protocol (MSP) is now supported. You must ftp the sounds to yor computer first - Wintin does not yet automatically download them on-the-fly. Under the edit menu you will find an option to configure various aspects of MSP.

The highlighting code has been rewritten.

Wintin now supports lists.

Version 1.64

You can now compare strings in if-statements, and if-statements can have 'else' clauses. This functionality was lifted from Tintin++ version 1.64, the version that never made it out of beta. As far as I can see, Wintin now has all the functionality of 1.64 that is relevant: a lot of the work in 1.64 was to do with screen handling and doesn't have any relevance to Wintin.

Function keys, cursor keys and various others can be used as shortcuts for commands via an extension to alias.

The full set of 16 foreground and 16 background colours should now work ok with an ANSI mud, and also in the highlight command.

You can specify a startup file on the command line, which will allow you to make separate desktop icons for the different muds or characters you play.

Text wrap has been improved: it now attempts to wrap at the end of a word. The wrap point is definable.

There is a 'select all' command to help you take a quick log on the fly.

Action and alias support a 'remainder' argument, %r, which will be substituted by the remaining text not used in other % arguments.

There are various small changes to help newbies. The FAQs I get include:

I started the program but I don't know what to do next

- There's now a 'Connect' menu item on the file menu which builds a #session command for you.

It says 'no tab.txt file, no completion list. What's wrong?

- I removed that message, it didn't really serve much purpose.

I can't get it to load a file on startup

- As well as looking for the traditional tintinrc file, Wintin now looks for tintinrc.txt, which is I hope a more natural file for Windows users.

I've included a bug fix from Feng Chen which ensures that Wintin disconnects from the mud properly when you close a session. Many thanks Feng :)

There are also bug fixes for the #return and #map commands, and for command history (the ! operator).

Version 1.20

Tired of losing settings and aliases when your session closes? The new update_update command lets you save changes back into the common lists.

The Definitions command on the Edit menu provides a graphical interface to aliases, actions, variables and so on.

Finally, there are some bug fixes which should resolve the remaining problems with ANSI color.

Version 1.10

Wintin now includes text and background coloring and font selection. Be careful not to set black text on a black background by mistake (!) and remember that in a proportional font (such as Times Roman) you get more characters on a line but text will not line up in columns as you might expect.

Wintin will now do its best to remember window sizes and positions from one invocation to the next.

All settings are now maintained in the user's registry rather than in an .ini file.

There is a preset variable, $time. See help on variable for details.

tickset now takes an optional parameter. See its help for details.


Legal Notices

You may use this version freely for personal use, and give it to others on the same basis. The program and help files are copyright: all rights are reserved and all other use is prohibited. In particular you may not exploit Wintin 95 for profit or make any charge for distributing it without obtaining my agreement in writing.

I'm sure the code is riddled with bugs. This program is intended to be used for pleasure. I make no representations that it is fit for any purpose, and I won't be held responsible for any consequences should it fail to work properly, which it probably will.

I will probably distribute any future versions of Wintin 95 on the same basis, but I reserve the right not to.

Wintin 95 incorporates a port of the public-domain Tintin++ code. This legal notice is not intended to make a claim on that code or restrict the rights of its authors in any way.

William Lees


Getting Started

What is Wintin 95?

Wintin 95 is a 'mud client': that is to say it is a program especially designed for playing text-based muds. It will work on a Windows 95 or Windows NT machine which is connected to the internet directly or via a modem and PPP or SLIP. Wintin 95 will also work over a straight 'dial-up' connection to a host. For decent performance, use Wintin 95 on a 486/66 or Pentium. It will probably be OK on slower machines, but you may find that it (or your machine, blame what you will) can't keep up with the fast scroll that you sometimes get on muds, particularly when fighting in a group.

There are several reasons for using Wintin 95 to mud. First of all, it's a good Telnet program. It has a large scrollback buffer (approximately 2000 lines). If you scroll back, Wintin 95 doesn't jump back to the current insertion point every time some new text arrives. Also you can split a window so that you can scroll back through the history while watching any new stuff that arrives. These are all features that I've wanted in *any* telnet program and never really found, which is why I started on Wintin 95 in the first place. Wintin 95 is also pretty fast compared to most Windows-based Telnets, and it has some special features in it designed to handle heavy scroll.

The other features that make Wintin 95 good for mudding come from its Tintin++ background. It has a powerful 'alias' facility, which lets you set up an unlimited number of shortcut commands for the things you find yourself doing a lot. It has an 'action' facility which you can use to automate things. For example you can set up actions to eat whenever you are hungry, fill a barrel every time you pass a fountain and so on. And you can roll your own colouring if you are using a mud that doesn't do colouring itself. Finally you can create special windows for different things: for example you can arrange that any text that is spoken to you by another character is captured in its own window where you will see it quite distinctly without it being swamped in scroll. And each window has 2000 lines of scrollback history, so you will keep things that people say to you for a long time...

Is Wintin 95 only good for hack-and-slash style muds? Well, it's true that it comes from a hack-and-slash background, and a lot of the commands are particularly useful in a fighting and spellcasting environment. But the general features described above should be useful in any mudding environment - and possibly in other contexts as well. Make your own mind up - and if there are particular features that would make it more useful on a particular kind of mud, let me know.

Lastly, a bit about Wintin 95's background. The program is really in two distinct lumps. The first bit is the Windows stuff: Wintin 95 is a Microsoft Foundation Classes application written in MS Visual C++. I wrote that bit myself. The second bit is the Tintin++ stuff. Tintin++ has been around as a Unix mud client for a long time. It is published in source code form, and at one stage was ported to Windows NT as a console application. The Tintin++ bit of Wintin 95 is based largely on the Windows NT console port, and I have made a full acknowledgement to the many people who have worked on Tintin++ in the Wintin 95 'about' screen.

I've included the Tintin 1.5 manual, with kind thanks to David Wagner for allowing me to do so. If you haven't used Tintin or Wintin before, you really need to read this - it will get you going and make sure that you understand all the features available. There's some extra functionality in Wintin, which you'll find listed in the 'what's new' section of this help file.


Installing Wintin 95

To install Wintin 95, copy the files included in the Zip to a directory somewhere, and create an icon for WINTIN 95.EXE.


Starting Wintin 95

To start Wintin 95, double-click on the icon you created for it.

When Wintin 95 starts, there is a single open window: the Wintin 95 window. Because Wintin 95 is written to be used with text-based muds, most of the commands are typed into it rather than being selected from a menu. You may like to review the menus now to see what is available: there is context-sensitive help available should you need it, which you probably won't, unless you're new to Windows.

Even when there are multiple windows open in Wintin 95, you can type commands into any window, you don't need to make a particular window active first. All windows have horizontal and vertical splitters on them, which work like the splitters in Excel and other Windows applications. All windows have a scrollback buffer which remembers roughly the last 2000 lines displayed in that window.

If you hit Enter a few times, you will see Wintin 95 complain that there is no active session. A session is the thing you set up to communicate with a mud. To set one up, pull down the File menu and select the Connect menu item. Just fill in the mud's address and port, and away you go. Alternatively, look at the help on the session_session command, or go to the next introductory section, Connecting to a Mud_connecting.


Connecting to a Mud

To connect to a mud you start a session. You need to think of a name for the session: I suggest you use the mud's name. You then type a command whch depends on the kind of connection you have to the Internet.

If your PC is directly connected to the Internet, or if you use a dialup connection to the Internet, read the part titled 'Connecting via the Internet' below. Otherwise, if you are going to dial a host (say some kind of Unix machine) via a modem, read the part titled 'Asynch Connections' which follows.

If you don't understand what the paragraph above means, don't worry about it. The chances are you use the Internet: just read the following section 'Connecting via the Internet' and forget about the 'Asynch connections' bit underneath it. If you don't understand what an asynch connection is, you almost certainly don't use one.

Connecting via the Internet

To connect to a mud, start up your internet connection, start Wintin, pull down the File menu and select 'Connect'. Fill in your mud's address and port number, and press OK.

If you get problems, check your internet connection is ok and that your mud is alive. Try some other way to connect to your mud, maybe it's down at the moment. Try some other mud through Wintin - if that works ok, the chances are your mud is down.

If things still don't work out, you may have one of two show-stopping problems. Firstly, I know that Wintin doesn't work with some kinds of firewall. So if you're mudding from work and you can't get through, it's probably the firewall. Unfortunately I don't have one I can play with, so until some kind soul does some detective work and tells me exactly what the problem is, I can't do much about this one. Sorry.

Secondly, Wintin is a 32 bit program and it MUST HAVE a 32 bit Winsock: WINSOCK32.DLL, NOT WINSOCK.DLL. There are still some people out there that are using Trumpet or some other way of connecting to the Internet that only provides a 16 bit Winsock. You can't use Wintin with that method. You can't use Real Audio or Navigator 4 or any of the other cool pieces of software either, so do yourself a favour and upgrade to WINSOCK32. It's FREE with Windows 95 or Windows 98, and it's on your Windows installation CD. Your ISP will help you set it up.

You can also connect to your mud by typing a command in rather than using the menu item. Look at the description of the session command for details.

Asynch Connections

If you are going to dial up a host such as a Unix machine and therefore don't have direct connection of any sort to the Internet, first work out the following:

- the port number your modem is on (COM1, COM2 or whatever)

- the speed (baud rate) at which you want to talk to your modem

- the number of data bits, parity type and number of stop bits that your host expects

If you have any trouble working out this information, you can probably figure it out by looking at whatever terminal program you use at the moment and cribbing the settings. If you don't use a terminal program at the moment you are reading the wrong section: you have an Internet connection and should read the section above called 'Connecting via the Internet'.

To connect to a modem on port 1 at 38400 baud with 8 data bits, no parity and one stop bit you would type

#ses sloth async,1,38400,8,n,1

To connect to a modem on port 3 at 9600 baud with 7 data bits, even parity and one stop bit you would type

#ses sloth async,3,9600,7,e,1

Once the session has started you must type the AT commands to the modem to make it dial and then log in to your host.

When you are using Wintin 95 through a com port, you may well find that everything you type is displayed on the screen twice: this is because Wintin 95 echoes the characters back to you as you type, and most hosts will echo everything back as they receive it. You will notice that Wintin 95 is echoing the command as you type it, whereas the host echoes it back after any aliases and so on have been processed. To avoid this double echo, see if the host you connect to has a command which will suppress its echo (this is typically used with 'simplex' terminals).

Now please move on to the next introductory session, Introduction to Commands to read how to take advantage of some of Wintin 95's capabilities once you have connected.


Introduction to Commands

You may have noticed in the coverage of the session command that Wintin 95 commands start with a special character, #, and can be abbreviated: for example the session command was shown in the examples abbreviated to #ses. You will have to experiment to see how much you can abbreviate a particular command. The special character that starts commands can be changed if necessary: see char.

There are two features of Wintin 95 which you can start to use right away. Firstly you can type several commands on the same line, separating them by a semicolon. Tintin++ will split them up before sending them to the mud. So to go 3 rooms west and say 'foo', you might type

w;w;w;say foo

Secondly, you can use speedwalk to walk around rapidly. For example you could abbreviate the above command to

3w;say foo

The next thing you will probably want to get to grips with is alias, which allows you to make an abbreviation for a commonly used command. For example you could make an abbreviation 'was' for the commands 'wake;stand'. To do this you would type

#alias was {wake;stand}

Notice here that the curly brackets are used to show Wintin 95 that the two commands 'wake;stand' form the alias. Otherwise it would assume that 'stand' was a command in its own right which followed the #alias command. You can put the curly brackets around any of the arguments following a Wintin 95 command.

As you build up useful aliases, you will want to store them in a file so you don't have to type them in each session. Look at read and write to see how to do this.

Next you will probably want to look at the highlight command to see how to colour text and send it to multiple windows, and the action command to see how to script automatic actions. But before you play with actions, please read the next introductory section, What should I know about 'Tintin++ Bugs?'. Wintin 95 contains some powerful features which unscrupulous players may try to use against you, and these are connected with how you write your actions. The next section will explain how to avoid the pitfalls.

Finally, to help you start off, the file WINTIN 95.CMD, which was supplied with Wintin 95, contains some example commands.


What Should I Know about 'Tintin++ Bugs'?

There are two 'features' of Tintin++ which have been exploited by players and are common knowledge in the mudding world.

The first is simply that the commonly used version of Tintin++ for Unix tends to display passwords on the screen instead of hiding them. This is a plain and simple bug and it has been corrected in Wintin 95, so you don't need to worry about it: if Wintin 95 does display your password on the screen please let me know and I'll do my best to fix the problem, but with any luck you will find that it doesn't.

The second is more of a feature than a bug but it can have very serious consequences and once you have read about the action command you should be aware of it. There is a very simple way of avoiding it, which is what this section is all about.

The problem is this. Suppose that you create an action like this:

#action {There were %0 coins.} {split %0}

Now suppose that someone says or emotes something like

Butthead says 'There were 0;rem all;give all butthead; coins

What happens is that Wintin 95 assigns '0;rem all;give all butthead' to %0 and sends off the line

split 0;rem all;give all butthead;

which results in your giving all your stuff to Butthead.

To get around this problem, always use $ instead of % in the second argument to #action, like this:

#action {There were %0 coins.} {split $0}

The $ works exactly like %, except that the ;s and everything following them are removed without being processed so that the same words from Butthead would simply make your Wintin 95 say

split 0

Once again: you will not encounter this problem provided that you always use $ in the second argument to #action instead of using %. Check this in any file of actions that people give you, in case they have overlooked it.

You shouldn't encounter any other problems as a result of using Wintin 95, but beware of the gag command: if you gag everything that someone does, they may harass you without your noticing it!



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

The [] signify optional arguments.

If you have not read it already, please read What should I know about 'Tintin++ Bugs?'_bugs before experimenting with actions.

Have the client search for a certain string of text from the mud, if the client receives that string, it will execute the command(s). Variables %0-9 are substituted from the input string, and can be used in the command(s) side of the command. A further variable, %r, is set to all the 'remaining' text after any other variables you have used.

Previously, all actions were stored alphabetically in the list, which meant that some of the important actions could exist at the end of the list (which could result in slow reaction times for those actions). Priorities have been added to actions now. The third parameter of the command will tell how important Wintin 95 should regard this action (0 most important, 9 least important). If no priority is given, a default value of 5 is assigned. If the string to be searched for starts with a ^, only the beginning of the line will be searched.

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

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


#action {Grimmy has arrived} {smile grimmy} {2}

If Grimmy enters the room, you will automatically smile at her. The priority setting of two, means that it should be stored close to the top of the list. (all actions with 1 and 0 set for priorities will be checked before this one).

#action {^TICKCOUNTER: 5 seconds} {sleep} {0}

Since this string is 'anchored', it will only be triggered if it starts at the beginning of a line. If your mud has a tickcounter set up like this, this action will make you sleep at 5 seconds to tick.


list all actions

#action *tell*

list all actions with the word 'tell' in them.



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

format: #alias [word] [command]

the [] signify optional arguments.

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

If the command(s) include variables %0-9, these are substituted as part of the parsing. %0 is set to all text after the word was input, %1 is set to the first word following the aliased word, and %2 is the second, and so on. A further variable, %r, is set to all the 'remaining' text after any other variables you have used.

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

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

You can assign aliases to function keys or some other keys. These aliases can't have variables. Use alias names from the following table to assign an alias to the associated function key:


You can't reassign F1, which is used for help. See the examples below to see how these are used.


#alias gb get bread bag

typing gb at the prompt would be sent as 'get bread bag'.

#alias ws {wake;stand}

since ws aliases a multiple command, you must use the braces.

#alias heal cast 'heal' %1

typing 'heal valgar' at the prompt would be sent as 'cast 'heal' valgar' since it will put the word valgar into %1

#alias VK_F2 flee

flee if you hit the F2 key

#alias VK_UP n

go north when you hit the uparrow key


list all aliases

#alias he*

list all aliases that start with the letters 'he'

#alias mtell %1 [Tom says:] %r

'mtell valgar come help me at the Griffin' will be sent as 'tell valgar [Tom says:] come help me at the Griffin' Back


format: #all {string}

#all string

Send a command to all open sessions.


#all {shout I'm multicharing!}



format: #antisubstitute {string}

#antisubstitute string

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


#antisub {^You}

any line starting with 'You' will not be checked for subs.

#antisub {^You%0hit.}

lines that start with 'You', and also contain 'hit.' will not be subbed.

#antisub {annihilate}

any line that contains the word 'annihilate' will not be subbed.



format: #bell

sends a beep to your terminal.


#action {tells you} {#bell}

will chime any time anyone tells you anything.



format: #boss

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



format: #char character

lets you redefine your Wintin 95_character, the character that starts all commands.


#char /

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

If you load a coms file, the first character it sees is set to your Wintin 95 char.



format: #cr

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



format: #echo

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



format: #end

terminate Wintin 95.



format: #gag {string}

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

Beware that Gag may expose you to thievery: if you gag someone's name, you won't see any descriptions of what they do. Likewise if you gag a fighting action and someone puts the same action in their description, you may not see them come and go.



format: #help [command]

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



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

#highlight [type] [{string}]

The [, ] signify optional arguments.

The higlight command is used to allow you to highlight strings of text from the mud, and to direct text to special windows.

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

You can specify a colour by its number or its name. Background colours are specified by the name prefixed by a 'b'. Possible colours are:

9light red
10light green
12light blue
13light magenta
14light cyan
16b black
17b red
18b green
19b brown
20b blue
21b magenta
22b cyan
23b white
24b charcoal
25b light red
26b light green
27b yellow
28b light blue
29b light magenta
30b light cyan
31b white


#high {blue} {Valgar}

print every occurrence of 'Valgar' in blue

#high {6} {%0tells you%1}

print every complete line that contains 'tells you' in color 6

#high red {^You}

Redden any 'You' that starts a line

#high {green} {Grimne}

each time the word Grimne appeared, it's to be shown in green.

To direct lines to a special Wintin 95 window, you should first set up the window using the openwin command. Then use Highlight to highlight any text to send to the window, only instead of a colour number specify the window number plus 60. Any lines containing the text will be sent to the special window.


#high {61} {%0tells you%1}

display every complete line that contains 'tells you' in window 1

#high {64} {^You}

display every line that starts with 'You' in window 4

The lines highlighted in this way will be displayed in the main Wintin 95 window as well as in the special window. If you don't want them displayed in the main window, use the window number plus 50 instead of the window number plus 60:

#high {51} {%0tells you%1}

display every complete line that contains 'tells you' in window 1

#high {54} {^You}

display every line that starts with 'You' in window 4

(see openwin for more examples)



format: #history

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




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

#if {conditional} {command(s)} else {command(s)}

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

#if can compare numerical or string values. Strings must be enclosed in square brackets as in the example below.


#action {%0 gives you %1 gold coins} {#if {%%1>5000} {thank %%0} else {burp}}

if someone gives you more than 5000 coins, thank them. If they give you less, burp.

the %%1 and %%0 belong to the action, and not to the if, and that is why

the double % are needed.

#action {^<hp:%0 } {#if {%%0<100} {flee}}

If your status prompt is of the form <hp:100 ma:50 mo:100>, this action will get your hit points, compare them to 100, if less than 100, flee

#action {Jake} {#if {[$ill]=[cold]} {cough}

When you see Jake, cough if the variable 'ill' is set to 'cold'.



format: #ignore

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



format: #info

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



format: #killall

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



A list is just a variable containing some text, but it is split into list 'elements' by commas. Here's an example of a list containing three elements:

#var {foo} {fee, fie, foe}

You can use a list just like a normal variable, for example

#showme $foo


fee, fie, foe

You can also use the special commands push, remove and select, a new variant of the loop command, and the @ variable modifier. See the command descriptions for details.



format: #log {filename}

Log session to a file.



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

or: #loop {listname} {commands}

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


#loop {1,3} {get all %0.corpse}

equivalent to the following:

get all 1.corpse;get all 2.corpse;get all 3.corpse

#loop {3,1} {drop %0.key}

equivalent to

drop 3.key;drop 2.key;drop 1.key

In the second form of the loop command, the commands are executed once for each element of the list, with the list elements placed in %0.


#var {recalls} {fred, tony, bill}

#loop {$recalls} {recite recall %0}

is equivalent to

recite recall fred; recite recall tony; recite recall bill

#loop {$@recalls} {recite recall %0}

wll generate the same commands, and will empty the list afterwards.



format: #map {direction}

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


#action {$leader leaves %0.} {#map {%%0}}

if the person stored in $leader leaves the room, the direction is added to the end of the path.



format: #mark

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



format: #math {variable} {expression}

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

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

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


#math {heals} {$mana/40}

Assuming there is a variable $mana, divide its value by 40 and store the

result in $heals.

#action {^You receive %0 experience} {updatexp %0}

#alias updatexp {#math {xpneed} {$xpneed-%%0}

Let's say you have a variable which stores xp needed for your next level. The above will modify that variable after every kill, showing the amount still needed.



format: #message {type}

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


#message {variable}

toggles whether messages dealing with variables will be shown.



format: #nop [string]

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


#nop This is the start of my autoactions



format: #openwin {number} {title}

This command is used to open 'special windows' which can display selected text from the active session. For example if your mud has a 'gossip' command, you can create a 'gossip' window which just shows you the gossip lines and nothing else. You could have another one for lines that were related to your group and so on. You can have up to 7 special windows, in addition to the main Wintin 95 window.

You set up special windows as follows. First of all, use the #openwin command to define the window. You tell it the window number and the title of the window. Then use highlight_highlight to specify the lines which you want to be sent to the special window.

Examples (see highlight_highlight as well)

#openwin {1} {Gossip}

#highlight {61} {%0 gossips-- %1}

The first command opens a special window (number 1) and titles it 'Gossip'. The second command sends all lines of the form

xxx gossips-- yyyyyyyy

to this special window, as well as displaying them in the main window.



format: #path

Show your current path.



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

This command will allow those who play on muds that have diagonal./odd directions to use speedwalk.


#pathdir {nw} {nw}

each time {nw} is encountered in the speedwalk, Wintin 95 will send a {nw} to the mud.



format: #presub

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



format: #push {variable} {value}

Add an element onto the end of a list variable. A list variable is just an ordinary variable in which 'elements' are separated by commas. Push adds a new element onto the list, automatically inserting the comma.

You can 'pop' elements off the list by referring to the list with the special @ syntax - see the example below. The '@' calls up the last element in the list, and then removes it from the list after use.


#var {foo} {fee, fie}

#push {$foo} {foe }

#showme $foo

fee, fie, foe

#showme $@foo


#showme $@foo


#showme $foo




format: #redraw

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



format: #retab

#retab re-loads the tab completion file.



format: #return

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



format: #rnd {var} {upperlimit}

Assign a random number between 0 and the given upper limit to the specified variable.


#rnd foo 10

#showme $foo



format: #read {filename}

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



format: #rmove {list} {element}

Removes the specified element from a list, if present. No error message is generated if the element is not in the list.


#var {foo} {fee, fie, foe, fum}

#remove {foo} {fie}

#showme $foo

fee, foe, fum



format: #savepath {alias name}

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



format: #select {listname,mode,current} {commands}

Select pulls an element out of a list and runs commands on it, in much the same way as #loop.

Listname is the name of the list

Mode is either next or prev

Current is an element in the list

Select will extract from the list the element immediately before or after current, depending on the mode setting. It will set the variable %0 equal to this element, and then process the specified commands.

Select loops around the elements, for example if the current element is the last in the list, requesting the next element will produce the first.


#var healer tony

#var heals {tony, bill, fred}

#alias nextheal {#select {heals, next, $healer} {#var healer %0; grouptell current healer is: %0}}

#alias prevheal {#select {heals, prev, $healer} {#var healer %0; grouptell Oops, healer is still: %0}}



format: #session

or #session

or #session async,1,9600,8,n,1

or #session

The Session command starts a session with a mud.

You can have as many open sessions as you want, but only one is the 'active' session at any particular point. Anything you type is sent to the active session only (but see all_all), and only text received from the active session is displayed in the windows (but see snoop_snoop). You can see which sessions you currently have open by typing #session on its own.

You give each session a name when you start it. You can switch to a session at any point by typing its name preceded by a # (or whatever the active Wintin 95 character is at the time).

To start a session, use the first two forms shown above if you are using Wintin 95 over an IP connection (that is to say that your PC is connected to the Internet, either directly or via PPP or SLIP). Use the third form (the async form ) if you are using Wintin 95 to communicate with a host over a serial line and a modem.

The parameters you pass in the async form tell Wintin 95 which com port to use, and then specify the speed, data bits, type of parity and number of stop bits. Some examples are given below. Generally speaking you should use a speed that is a bit higher than the maximum speed your modem can work at, to allow for compression, and either 8,n,1 or 7,e,1.

The async command will leave you talking to the modem on the specified com port. It is then up to you to give the modem the necessary commands (ATDT etc) to call the host, and then type whatever it takes to log in to the mud.

When you are using Wintin 95 through a com port, you may well find that everything you type is displayed on the screen twice: this is because Wintin 95 echoes the characters back to you as you type, and most hosts will echo everything back as they receive it. You will notice that Wintin 95 is echoing the command as you type it, whereas the host echoes it back after any aliases and so on have been processed. To avoid this double echo, see if the host you connect to has a command which will suppress its echo (this is typically used with 'simplex' terminals).


#ses ai 6101 connect to port 6101 on

#ses ai 6101 connect to port 6101 at ip address

#ses ai async,1,38400,8,n,1 connect to COM1 at 38400 baud, 8-n-1

#ses ai async,3,9600,7,e,1 connect to COM3 at 9600 baud, 7-e-1



format: #showme {string}

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

status, warnings, etc.


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



format: #snoop {session name}

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



format: #sound {file name}

Plays the sound from the specified file. The file can be in any registered format such as .wav or midi.



format: #speedwalk

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


without speedwalk:


with speedwalk:




format: #split

The Split command opens a new window, Input, and directs all keyboard input to that window so that you can see it without it being muddled up with text received from the Mud.



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

The [] signify optional arguments.

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

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

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

If no argument is given, all subs are displayed.


#sub {leaves} {.}

gag any line that has the word 'leaves' in it.

#sub {^Zoe%0} {ZOE%0}

any line that starts with the name Zoe will be replaced by a line that

starts with 'ZOE'

#sub {%0massacres%1} {%0MASSACRES%1}

replace all occurrences of 'massacres' with 'MASSACRES'



format: #suspend

The Tintin++ Suspend command is not supported by Wintin 95.



format: #system {command}

The Tintin++ System command is not supported by Wintin 95.



format: #tabadd {word}

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



format: #tabdelete {word}

Deletes a word from the tab completion list.



format: #tablist

Displays all words in the tab completion list.



format: #textin {filename}

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



format: #tick

Show seconds until next tick.



format: #tickoff

Turn off the Wintin 95 built in tick counter.



format: #tickset [{seconds}]

Turn on the Wintin 95 tickcounter, and set time until next tick equal to tick size.

If you specify the optional 'seconds' parameter, the ticker will only be reset if it is currently within that many seconds of a tick.

Eg #tickset 10 - reset the ticker if we are currently within 10 seconds of a tick.

The 'seconds' parameter is useful if you want to use an increase in mana or movement to detect a tick: it will eliminate false resets caused by a long gap between prompts when you are idle.

Here is an example based on a prompt of the form <645hp 330ma 162mv>

#message variable

#var oldmv

#var newmv

#alias newmv {#if {%%1 > $oldmv} {#showme ..TICK..;#tickset 10};#var oldmv %1}

#alias newma {#if {%%1 > $oldma} {#showme ..TICK..;#tickset 10};#var oldma %1}

#action {^<%0hp %1ma %2mv>} {newma $1;newmv $2}



format: #ticksize number

Set a new time, in seconds, between ticks for the Wintin 95 tickcounter.



format: #tolower var text

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



format: #togglesubs

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



format: #toupper var text

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



format: #unaction {string}

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


#unaction {%0tells you%1}

remove the action that is triggered by '%0tells you%1'

#unaction *

remove all actions

#unaction {*massacre*}

remove all actions that contain the word 'massacre'



format: #unalias {word}

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


#unalias {bbb}

remove the alias 'bbb'

#unalias *

remove all aliases

#unalias {*go*}

remove all aliases that contain the fragment 'go'



format: #unantisubstitute {string

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


#unantisub {%0tells you%1}

remove the antisub for '%0tells you%1'

#unantisub *

remove all antisubs

#unantisub {^You*}

remove all antisubs that start with '^You'



format: #ungag {string}

Exactly the same as unsubstitute.



format: #unsubstitute {string}

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


#unsub {%0tells you%1}

remove the sub for '%0tells you%1'

#unsub *

remove all subs

#unsub {^You*}

remove all subs that start with '^You'



format: #unhighlight {string}

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


#unhigh {%0tells you%1}

remove the highlight for '%0tells you%1'

#unhigh *

remove all highlights

#unhigh {^You*}

remove all highlights that start with '^You'



format: #unpath

Remove the most recent move from the current path.



format: #unsplit

The Unsplit command causes keyboard text to be directed to the Wintin window as opposed to the separate Input window.



format: #unvariable {variable name}

#unalias variable name

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


#unvar {hp}

remove the variable $hp

#unvar *

remove all variables

#unvariable {xx*}

remove all variables that start with 'xx'



format: #update

This command toggles the 'update common lists' mode on and off. When update mode is on, every time a session dies the current variables, actions, aliases and other settings are copied back to the common lists so that they are applied to any new sessions started. This is useful if you maintain variables with the group leader's name and so on which you don't want to lose if your link goes down in mid session.

When update mode is off, any changes are discarded when the session drops - this is the behaviour of tintin++ and is appropriate if you connect to several muds simultaneously with different aliases for each.



format: #variable {} {}

These variables differ from the %0-9 in the fact that you can specify a full word as a variable name, and they stay in memory for the full session, unless they are changed, and they can be saved in the coms file, and can be set to different values if you have 2 or more sessions running at the same time. One of the best uses for variables is for spellcasters.

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

#alias {flame} {cast 'flame strike' %0}

#alias {flash} {cast 'call lightning' %0}

#alias {harm} {cast 'harm' %0}

With the new variables you can do the following:

#alias {targ} {#var target %0}

#alias {flamet} {flame $target}

#alias {flasht} {flash $target}

#alias {harmt} {harm $target}

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

so, if before a battle, you do a:

targ donjonkeeper

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

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

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

tells your group 'target=lich'

you could then set an action like so.

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

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

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

There is a predefined variable $time which is set equal to the number of seconds since Wintin started. You can use this to time things (by recording a start time and an end time in different variables). Possible uses are: ?

use with an experience point counter to calculate xp gained per hour ?

construct a lag timer (send a command to the mud, time how long it takes to get a reply, keep a running count) ?

limit an action so that it happens at most once every so many seconds (useful for building an action that happens just once per round in a fight).



format: #verbatim

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



format: #version

Show the version number of Wintin 95 that you are currently running.



format: #command {regexp}

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


#action {*miss*}

shows all actions which contain the word miss in them

#unaction {*miss*}

removes all actions which contain the word miss in them

#unaction {\*\*\* PRESS RETURN:}

removes the action which triggers on the line *** PRESS RETURN:



format: #wizlist

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



format: #write {filename}

#write filename

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



format: #writesession {filename}

#writesession filename

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



format: #zap

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