multiplaying
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
william@wintin.org
http://www.wintin.org
Wintin 95 Commands
BackNew in this release
Version 1.80
Command history and command editing! Use up-arrow and down-arrow to move through command history, left-arrow, right-arrow and delete to edit a command on the command line, and Esc to abandon a line.
It is now possible to display text on the status bar. The Tick countdown is automatically displayed there. See the #panel command for details. Use the View menu command to enable the status bar.
The new #capture command makes it possible to save incoming text into a list. This is useful for processing and acting on a multi-line response from the mud.
The #select command has been extended to incorporate modes that will be useful when checking a list against a range of desired contents.
The new #match command allows you to transform the format of list items.
#echo now sends information to the dedicated debug window. The info it sends has been improved, too. The new #debug command allows you to print additional info to the debug window.
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).
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.
BackLegal 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
william@wintin.org http://www.wintin.org
BackGetting 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.
BackInstalling 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.
BackStarting 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.
BackConnecting 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!
BackAction
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.
examples:
#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.
#action
list all actions
#action *tell*
list all actions with the word 'tell' in them.
BackAlias
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.
examples:
#alias gb get bread bag
typing gb at the prompt would be sent as 'get bread bag'.
#alias ws {wake;stand}
since ws aliases a multiple command, you must use the braces.
#alias heal cast 'heal' %1
typing 'heal valgar' at the prompt would be sent as 'cast 'heal' valgar' since it will put the word valgar into %1
#alias VK_F2 flee
flee if you hit the F2 key
#alias VK_UP n
go north when you hit the uparrow key
#alias
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
All
format: #all {string}
#all string
Send a command to all open sessions.
example:
#all {shout I'm multicharing!}
BackAntisubstitute
format: #antisubstitute {string}
#antisubstitute string
Will cause any line that contains the string specified to not be checked for substitutes and gags. The ^ char starting a string will tell the client to only antisubstitute lines that START with the string specified.
examples:
#antisub {^You}
any line starting with 'You' will not be checked for subs.
#antisub {^You%0hit.}
lines that start with 'You', and also contain 'hit.' will not be subbed.
#antisub {annihilate}
any line that contains the word 'annihilate' will not be subbed.
BackBell
format: #bell
sends a beep to your terminal.
example:
#action {tells you} {#bell}
will chime any time anyone tells you anything.
BackBoss
format: #boss
puts some fake text on your screen so nobody knows you're mudding.
BackCapture
format #capture
Captures all text sent by the mud into the named variable, until the specified pattern is encountered or the variable reaches its limit.
example:
#capture buf {^[}
captures all text into the variable 'buf' until a line starting with '[' is encountered.
BackChar
format: #char character
lets you redefine your Wintin 95_character, the character that starts all commands.
example:
#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.
BackCR
format: #cr
Sends a carriage return to the session. Useful for aliases that need carriage returns.
Debug
format: #debug
Sends the string (which may contain variables) to the debug window. Back
Echo
format: #echo
Echo is used to see what actions are being triggered. #echo toggles this feature on and off, or use 'echo on' or 'echo off'.
End
format: #end
terminate Wintin 95.
Gag
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.
BackHelp
format: #help [command]
get a listing of commands, or get help and a specific command.
Highlight
format: #highlight [{type}] [{string}]
#highlight [type] [{string}]
The [, ] signify optional arguments.
The higlight command is used to allow you to highlight strings of text from the mud, 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:
| 0 | black |
| 1 | red |
| 2 | green |
| 3 | brown |
| 4 | blue |
| 5 | magenta |
| 6 | cyan |
| 7 | white |
| 8 | charcoal |
| 9 | light red |
| 10 | light green |
| 11 | yellow |
| 12 | light blue |
| 13 | light magenta |
| 14 | light cyan |
| 16 | b black |
| 17 | b red |
| 18 | b green |
| 19 | b brown |
| 20 | b blue |
| 21 | b magenta |
| 22 | b cyan |
| 23 | b white |
| 24 | b charcoal |
| 25 | b light red |
| 26 | b light green |
| 27 | b yellow |
| 28 | b light blue |
| 29 | b light magenta |
| 30 | b light cyan |
| 31 | b white |
examples:
#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.
examples:
#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)
History
format: #history
The history command will display a listing of the most recent keyboard
input.
If
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.
examples:
#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'.
Ignore
format: #ignore
Toggle actions on and off. If off, no actions will be checked for.
Info
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.
Killall
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.
BackLists
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
produces
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.
BackLog
format: #log {filename}
Log session to a file.
Loop
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.
examples:
#loop {1,3} {get all %0.corpse}
equivalent to the following:
get all 1.corpse;get all 2.corpse;get all 3.corpse
#loop {3,1} {drop %0.key}
equivalent to
drop 3.key;drop 2.key;drop 1.key
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.
Examples:
#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.
Map
format: #map {direction}
Will add a direction to the end of the current path. Useful for mapping while following someone.
example:
#action {$leader leaves %0.} {#map {%%0}}
if the person stored in $leader leaves the room, the direction is added to the end of the path.
Mark
format: #mark
Clear the path list and start the new path at your current location.
BackMatch
format: #match {outlist} {inlist} {match} {format}
Elements in the list 'inlist' are examined. Those matching the 'match' string are reformatted according to the 'format' specification, and then copied to the list 'outlist'. Previous conteonts of 'outlist' are discarded.
example:
#var ab {Gangrel [31], Blaster [34], Zarc [32], Drizzt}
#match {ba} {ab} {%1 [%2]} {%1}
ba will now contain {Gangrel, Blaster, Zarc}
BackMath
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.
examples:
#math {heals} {$mana/40}
Assuming there is a variable $mana, divide its value by 40 and store the
result in $heals.
#action {^You receive %0 experience} {updatexp %0}
#alias updatexp {#math {xpneed} {$xpneed-%%0}
Let's say you have a variable which stores xp needed for your next level. The above will modify that variable after every kill, showing the amount still needed.
Message
format: #message {type}
This will toggle off and on the messages dealing with a certain type of command. The possible message types are alias, action, antisub, sub variable, and highlight. This is very helpful if you are using #math and #if, and setting a lot of variables, so you don't keep getting the Variable Set messages.
example:
#message {variable}
toggles whether messages dealing with variables will be shown.
Nop
format: #nop [string]
A null operation, is ignored by the client. It is useful for commenting in your coms file, any text after the nop and before a semicolon or end of line is ignored.
example:
#nop This is the start of my autoactions
BackOpenwin
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.
BackPanel
format: #panel {number} {text}
Display the text in the indicated panel (currently 1 or 2). The text can contain variables.
BackPath
format: #path
Show your current path.
BackPathdir
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.
example:
#pathdir {nw} {nw}
each time {nw} is encountered in the speedwalk, Wintin 95 will send a {nw} to the mud.
BackPresub
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.
BackPush
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.
Example:
#var {foo} {fee, fie}
#push {$foo} {foe }
#showme $foo
fee, fie, foe
#showme $@foo
foe
#showme $@foo
fie
#showme $foo
fee
BackRedraw
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.
BackRetab
format: #retab
#retab re-loads the tab completion file.
BackReturn
format: #return
Pop the last move off the top of the path, and move the opposite direction.
BackRead
format: #read {filename}
Reads a coms file into memory. The coms file is merged in with the currently loaded commands. Duplicate commands are overwritten.
BackRemove
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.
Example:
#var {foo} {fee, fie, foe, fum}
#remove {foo} {fie}
#showme $foo
fee, foe, fum
BackRndnum
format: #rndnum {variable} {upperlimit}
Assigns a random number between 0 and 'upperlimit' to the variable.
BackSavepath
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.
BackSelect
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 next, prev, missing or found
Current is an element in the list
With 'next' or 'prev' modes, 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. The 'missing' mode will execute the commands only if 'current' is not found in the list, and the 'found' mode only if 'current' is found in the list.
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.
Example:
#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}}
Session
format: #session
or #session
or #session
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).
examples:
#ses ai ai.eecs.ukans.edu 6101 connect to port 6101 on ai.eecs.ukans.edu
#ses ai 129.237.80.129 6101 connect to port 6101 at ip address 129.237.80.129
#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
BackShowme
format: #showme {string}
Display the string to the terminal, do not send to the mud. Useful for
status, warnings, etc.
example:
#action {%0 ultraslays you} {#showme {#####argh! we were ultraslayed ######}}
BackSnoop
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%'.
BackSound
format: #sound {file name}
Plays the sound from the specified file. The file can be in any registered format such as .wav or midi.
BackSpeedwalk
format: #speedwalk
Toggle speedwalking on and off. Speedwalking allows you to type multiple directions not seperated by semicolons, and now it lets you prefix a direction with a number, to signify how many times to go that direction.
example:
without speedwalk:
s;s;w;w;w;w;w;s;s;s;w;w;w;n;n;w
with speedwalk:
2s5w3s3w2nw
Split
format: #split
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.
BackSubstitute
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.
examples:
#sub {leaves} {.}
gag any line that has the word 'leaves' in it.
#sub {^Zoe%0} {ZOE%0}
any line that starts with the name Zoe will be replaced by a line that
starts with 'ZOE'
#sub {%0massacres%1} {%0MASSACRES%1}
replace all occurrences of 'massacres' with 'MASSACRES'
BackSuspend
format: #suspend
The Tintin++ Suspend command is not supported by Wintin 95.
BackSystem
format: #system {command}
The Tintin++ System command is not supported by Wintin 95.
BackTabadd
format: #tabadd {word}
Adds a word to the end of the tab completion list.
BackTabdelete
format: #tabdelete {word}
Deletes a word from the tab completion list.
BackTablist
format: #tablist
Displays all words in the tab completion list.
Textin
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.
Tick
format: #tick
Show seconds until next tick.
Tickoff
format: #tickoff
Turn off the Wintin 95 built in tick counter.
Tickset
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}
BackTicksize
format: #ticksize number
Set a new time, in seconds, between ticks for the Wintin 95 tickcounter.
BackTolower
format: #tolower var text
Just like the #variable command, only it converts the text to lowercase before assigning it to the variable.
BackTogglesubs
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.
BackToupper
format: #toupper var text
Just like the #variable command, only it converts the text to uppercase before assigning it to the variable.
BackUnaction
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.
examples:
#unaction {%0tells you%1}
remove the action that is triggered by '%0tells you%1'
#unaction *
remove all actions
#unaction {*massacre*}
remove all actions that contain the word 'massacre'
BackUnalias
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.
examples:
#unalias {bbb}
remove the alias 'bbb'
#unalias *
remove all aliases
#unalias {*go*}
remove all aliases that contain the fragment 'go'
BackUnantisubstitute
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
examples:
#unantisub {%0tells you%1}
remove the antisub for '%0tells you%1'
#unantisub *
remove all antisubs
#unantisub {^You*}
remove all antisubs that start with '^You'
BackUngag
format: #ungag {string}
Exactly the same as unsubstitute.
BackUnsubstitute
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
examples:
#unsub {%0tells you%1}
remove the sub for '%0tells you%1'
#unsub *
remove all subs
#unsub {^You*}
remove all subs that start with '^You'
Unhighlight
format: #unhighlight {string}
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.
examples:
#unhigh {%0tells you%1}
remove the highlight for '%0tells you%1'
#unhigh *
remove all highlights
#unhigh {^You*}
remove all highlights that start with '^You'
Unpath
format: #unpath
Remove the most recent move from the current path.
Unsplit
format: #unsplit
The Unsplit command causes keyboard text to be directed to the Wintin window as opposed to the separate Input window.
Unvariable
format: #unvariable {variable name}
#unalias variable name
Remove variable(s) from the variable list which match {variable name}. The '*' character will act as a wildcard and will match any text. See wildcard_wildcard.
examples:
#unvar {hp}
remove the variable $hp
#unvar *
remove all variables
#unvariable {xx*}
remove all variables that start with 'xx'
Update
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.
Variable
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:
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).
Verbatim
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.
Version
format: #version
Show the version number of Wintin 95 that you are currently running.
Wildcard
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, \.
Examples:
#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:
BackWizlist
format: #wizlist
Lists the names of people who helped with with mudding, and with the client.If you feel your name should be here, let me know, so many people have contributed, and it's hard to name everyone.
Write
format: #write {filename}
#write filename
Writes all current actions, aliases, subs, antisubs, highlights, and variables to a coms file, specified by filename.
Writesession
format: #writesession {filename}
#writesession filename
Write all current actions, aliases, subs, antisubs, highlights, and variables that are specific to your current session to a file. This means actions that were not defined when there was no session active.
Zap
format: #zap
Kill your current session. If there is no current session, it will cause the program to terminate.