tt/ 0000750 0601750 0601001 00000000000 13657576565 010766 5 ustar eigenaar None tt/COPYING 0000664 0601750 0601001 00000104515 13555611364 012016 0 ustar eigenaar None GNU GENERAL PUBLIC LICENSE
Version 3, 29 June 2007
Copyright (C) 2007 Free Software Foundation, Inc.
Everyone is permitted to copy and distribute verbatim copies
of this license document, but changing it is not allowed.
Preamble
The GNU General Public License is a free, copyleft license for
software and other kinds of works.
The licenses for most software and other practical works are designed
to take away your freedom to share and change the works. By contrast,
the GNU General Public License is intended to guarantee your freedom to
share and change all versions of a program--to make sure it remains free
software for all its users. We, the Free Software Foundation, use the
GNU General Public License for most of our software; it applies also to
any other work released this way by its authors. You can apply it to
your programs, too.
When we speak of free software, we are referring to freedom, not
price. Our General Public Licenses are designed to make sure that you
have the freedom to distribute copies of free software (and charge for
them if you wish), that you receive source code or can get it if you
want it, that you can change the software or use pieces of it in new
free programs, and that you know you can do these things.
To protect your rights, we need to prevent others from denying you
these rights or asking you to surrender the rights. Therefore, you have
certain responsibilities if you distribute copies of the software, or if
you modify it: responsibilities to respect the freedom of others.
For example, if you distribute copies of such a program, whether
gratis or for a fee, you must pass on to the recipients the same
freedoms that you received. You must make sure that they, too, receive
or can get the source code. And you must show them these terms so they
know their rights.
Developers that use the GNU GPL protect your rights with two steps:
(1) assert copyright on the software, and (2) offer you this License
giving you legal permission to copy, distribute and/or modify it.
For the developers' and authors' protection, the GPL clearly explains
that there is no warranty for this free software. For both users' and
authors' sake, the GPL requires that modified versions be marked as
changed, so that their problems will not be attributed erroneously to
authors of previous versions.
Some devices are designed to deny users access to install or run
modified versions of the software inside them, although the manufacturer
can do so. This is fundamentally incompatible with the aim of
protecting users' freedom to change the software. The systematic
pattern of such abuse occurs in the area of products for individuals to
use, which is precisely where it is most unacceptable. Therefore, we
have designed this version of the GPL to prohibit the practice for those
products. If such problems arise substantially in other domains, we
stand ready to extend this provision to those domains in future versions
of the GPL, as needed to protect the freedom of users.
Finally, every program is threatened constantly by software patents.
States should not allow patents to restrict development and use of
software on general-purpose computers, but in those that do, we wish to
avoid the special danger that patents applied to a free program could
make it effectively proprietary. To prevent this, the GPL assures that
patents cannot be used to render the program non-free.
The precise terms and conditions for copying, distribution and
modification follow.
TERMS AND CONDITIONS
0. Definitions.
"This License" refers to version 3 of the GNU General Public License.
"Copyright" also means copyright-like laws that apply to other kinds of
works, such as semiconductor masks.
"The Program" refers to any copyrightable work licensed under this
License. Each licensee is addressed as "you". "Licensees" and
"recipients" may be individuals or organizations.
To "modify" a work means to copy from or adapt all or part of the work
in a fashion requiring copyright permission, other than the making of an
exact copy. The resulting work is called a "modified version" of the
earlier work or a work "based on" the earlier work.
A "covered work" means either the unmodified Program or a work based
on the Program.
To "propagate" a work means to do anything with it that, without
permission, would make you directly or secondarily liable for
infringement under applicable copyright law, except executing it on a
computer or modifying a private copy. Propagation includes copying,
distribution (with or without modification), making available to the
public, and in some countries other activities as well.
To "convey" a work means any kind of propagation that enables other
parties to make or receive copies. Mere interaction with a user through
a computer network, with no transfer of a copy, is not conveying.
An interactive user interface displays "Appropriate Legal Notices"
to the extent that it includes a convenient and prominently visible
feature that (1) displays an appropriate copyright notice, and (2)
tells the user that there is no warranty for the work (except to the
extent that warranties are provided), that licensees may convey the
work under this License, and how to view a copy of this License. If
the interface presents a list of user commands or options, such as a
menu, a prominent item in the list meets this criterion.
1. Source Code.
The "source code" for a work means the preferred form of the work
for making modifications to it. "Object code" means any non-source
form of a work.
A "Standard Interface" means an interface that either is an official
standard defined by a recognized standards body, or, in the case of
interfaces specified for a particular programming language, one that
is widely used among developers working in that language.
The "System Libraries" of an executable work include anything, other
than the work as a whole, that (a) is included in the normal form of
packaging a Major Component, but which is not part of that Major
Component, and (b) serves only to enable use of the work with that
Major Component, or to implement a Standard Interface for which an
implementation is available to the public in source code form. A
"Major Component", in this context, means a major essential component
(kernel, window system, and so on) of the specific operating system
(if any) on which the executable work runs, or a compiler used to
produce the work, or an object code interpreter used to run it.
The "Corresponding Source" for a work in object code form means all
the source code needed to generate, install, and (for an executable
work) run the object code and to modify the work, including scripts to
control those activities. However, it does not include the work's
System Libraries, or general-purpose tools or generally available free
programs which are used unmodified in performing those activities but
which are not part of the work. For example, Corresponding Source
includes interface definition files associated with source files for
the work, and the source code for shared libraries and dynamically
linked subprograms that the work is specifically designed to require,
such as by intimate data communication or control flow between those
subprograms and other parts of the work.
The Corresponding Source need not include anything that users
can regenerate automatically from other parts of the Corresponding
Source.
The Corresponding Source for a work in source code form is that
same work.
2. Basic Permissions.
All rights granted under this License are granted for the term of
copyright on the Program, and are irrevocable provided the stated
conditions are met. This License explicitly affirms your unlimited
permission to run the unmodified Program. The output from running a
covered work is covered by this License only if the output, given its
content, constitutes a covered work. This License acknowledges your
rights of fair use or other equivalent, as provided by copyright law.
You may make, run and propagate covered works that you do not
convey, without conditions so long as your license otherwise remains
in force. You may convey covered works to others for the sole purpose
of having them make modifications exclusively for you, or provide you
with facilities for running those works, provided that you comply with
the terms of this License in conveying all material for which you do
not control copyright. Those thus making or running the covered works
for you must do so exclusively on your behalf, under your direction
and control, on terms that prohibit them from making any copies of
your copyrighted material outside their relationship with you.
Conveying under any other circumstances is permitted solely under
the conditions stated below. Sublicensing is not allowed; section 10
makes it unnecessary.
3. Protecting Users' Legal Rights From Anti-Circumvention Law.
No covered work shall be deemed part of an effective technological
measure under any applicable law fulfilling obligations under article
11 of the WIPO copyright treaty adopted on 20 December 1996, or
similar laws prohibiting or restricting circumvention of such
measures.
When you convey a covered work, you waive any legal power to forbid
circumvention of technological measures to the extent such circumvention
is effected by exercising rights under this License with respect to
the covered work, and you disclaim any intention to limit operation or
modification of the work as a means of enforcing, against the work's
users, your or third parties' legal rights to forbid circumvention of
technological measures.
4. Conveying Verbatim Copies.
You may convey verbatim copies of the Program's source code as you
receive it, in any medium, provided that you conspicuously and
appropriately publish on each copy an appropriate copyright notice;
keep intact all notices stating that this License and any
non-permissive terms added in accord with section 7 apply to the code;
keep intact all notices of the absence of any warranty; and give all
recipients a copy of this License along with the Program.
You may charge any price or no price for each copy that you convey,
and you may offer support or warranty protection for a fee.
5. Conveying Modified Source Versions.
You may convey a work based on the Program, or the modifications to
produce it from the Program, in the form of source code under the
terms of section 4, provided that you also meet all of these conditions:
a) The work must carry prominent notices stating that you modified
it, and giving a relevant date.
b) The work must carry prominent notices stating that it is
released under this License and any conditions added under section
7. This requirement modifies the requirement in section 4 to
"keep intact all notices".
c) You must license the entire work, as a whole, under this
License to anyone who comes into possession of a copy. This
License will therefore apply, along with any applicable section 7
additional terms, to the whole of the work, and all its parts,
regardless of how they are packaged. This License gives no
permission to license the work in any other way, but it does not
invalidate such permission if you have separately received it.
d) If the work has interactive user interfaces, each must display
Appropriate Legal Notices; however, if the Program has interactive
interfaces that do not display Appropriate Legal Notices, your
work need not make them do so.
A compilation of a covered work with other separate and independent
works, which are not by their nature extensions of the covered work,
and which are not combined with it such as to form a larger program,
in or on a volume of a storage or distribution medium, is called an
"aggregate" if the compilation and its resulting copyright are not
used to limit the access or legal rights of the compilation's users
beyond what the individual works permit. Inclusion of a covered work
in an aggregate does not cause this License to apply to the other
parts of the aggregate.
6. Conveying Non-Source Forms.
You may convey a covered work in object code form under the terms
of sections 4 and 5, provided that you also convey the
machine-readable Corresponding Source under the terms of this License,
in one of these ways:
a) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by the
Corresponding Source fixed on a durable physical medium
customarily used for software interchange.
b) Convey the object code in, or embodied in, a physical product
(including a physical distribution medium), accompanied by a
written offer, valid for at least three years and valid for as
long as you offer spare parts or customer support for that product
model, to give anyone who possesses the object code either (1) a
copy of the Corresponding Source for all the software in the
product that is covered by this License, on a durable physical
medium customarily used for software interchange, for a price no
more than your reasonable cost of physically performing this
conveying of source, or (2) access to copy the
Corresponding Source from a network server at no charge.
c) Convey individual copies of the object code with a copy of the
written offer to provide the Corresponding Source. This
alternative is allowed only occasionally and noncommercially, and
only if you received the object code with such an offer, in accord
with subsection 6b.
d) Convey the object code by offering access from a designated
place (gratis or for a charge), and offer equivalent access to the
Corresponding Source in the same way through the same place at no
further charge. You need not require recipients to copy the
Corresponding Source along with the object code. If the place to
copy the object code is a network server, the Corresponding Source
may be on a different server (operated by you or a third party)
that supports equivalent copying facilities, provided you maintain
clear directions next to the object code saying where to find the
Corresponding Source. Regardless of what server hosts the
Corresponding Source, you remain obligated to ensure that it is
available for as long as needed to satisfy these requirements.
e) Convey the object code using peer-to-peer transmission, provided
you inform other peers where the object code and Corresponding
Source of the work are being offered to the general public at no
charge under subsection 6d.
A separable portion of the object code, whose source code is excluded
from the Corresponding Source as a System Library, need not be
included in conveying the object code work.
A "User Product" is either (1) a "consumer product", which means any
tangible personal property which is normally used for personal, family,
or household purposes, or (2) anything designed or sold for incorporation
into a dwelling. In determining whether a product is a consumer product,
doubtful cases shall be resolved in favor of coverage. For a particular
product received by a particular user, "normally used" refers to a
typical or common use of that class of product, regardless of the status
of the particular user or of the way in which the particular user
actually uses, or expects or is expected to use, the product. A product
is a consumer product regardless of whether the product has substantial
commercial, industrial or non-consumer uses, unless such uses represent
the only significant mode of use of the product.
"Installation Information" for a User Product means any methods,
procedures, authorization keys, or other information required to install
and execute modified versions of a covered work in that User Product from
a modified version of its Corresponding Source. The information must
suffice to ensure that the continued functioning of the modified object
code is in no case prevented or interfered with solely because
modification has been made.
If you convey an object code work under this section in, or with, or
specifically for use in, a User Product, and the conveying occurs as
part of a transaction in which the right of possession and use of the
User Product is transferred to the recipient in perpetuity or for a
fixed term (regardless of how the transaction is characterized), the
Corresponding Source conveyed under this section must be accompanied
by the Installation Information. But this requirement does not apply
if neither you nor any third party retains the ability to install
modified object code on the User Product (for example, the work has
been installed in ROM).
The requirement to provide Installation Information does not include a
requirement to continue to provide support service, warranty, or updates
for a work that has been modified or installed by the recipient, or for
the User Product in which it has been modified or installed. Access to a
network may be denied when the modification itself materially and
adversely affects the operation of the network or violates the rules and
protocols for communication across the network.
Corresponding Source conveyed, and Installation Information provided,
in accord with this section must be in a format that is publicly
documented (and with an implementation available to the public in
source code form), and must require no special password or key for
unpacking, reading or copying.
7. Additional Terms.
"Additional permissions" are terms that supplement the terms of this
License by making exceptions from one or more of its conditions.
Additional permissions that are applicable to the entire Program shall
be treated as though they were included in this License, to the extent
that they are valid under applicable law. If additional permissions
apply only to part of the Program, that part may be used separately
under those permissions, but the entire Program remains governed by
this License without regard to the additional permissions.
When you convey a copy of a covered work, you may at your option
remove any additional permissions from that copy, or from any part of
it. (Additional permissions may be written to require their own
removal in certain cases when you modify the work.) You may place
additional permissions on material, added by you to a covered work,
for which you have or can give appropriate copyright permission.
Notwithstanding any other provision of this License, for material you
add to a covered work, you may (if authorized by the copyright holders of
that material) supplement the terms of this License with terms:
a) Disclaiming warranty or limiting liability differently from the
terms of sections 15 and 16 of this License; or
b) Requiring preservation of specified reasonable legal notices or
author attributions in that material or in the Appropriate Legal
Notices displayed by works containing it; or
c) Prohibiting misrepresentation of the origin of that material, or
requiring that modified versions of such material be marked in
reasonable ways as different from the original version; or
d) Limiting the use for publicity purposes of names of licensors or
authors of the material; or
e) Declining to grant rights under trademark law for use of some
trade names, trademarks, or service marks; or
f) Requiring indemnification of licensors and authors of that
material by anyone who conveys the material (or modified versions of
it) with contractual assumptions of liability to the recipient, for
any liability that these contractual assumptions directly impose on
those licensors and authors.
All other non-permissive additional terms are considered "further
restrictions" within the meaning of section 10. If the Program as you
received it, or any part of it, contains a notice stating that it is
governed by this License along with a term that is a further
restriction, you may remove that term. If a license document contains
a further restriction but permits relicensing or conveying under this
License, you may add to a covered work material governed by the terms
of that license document, provided that the further restriction does
not survive such relicensing or conveying.
If you add terms to a covered work in accord with this section, you
must place, in the relevant source files, a statement of the
additional terms that apply to those files, or a notice indicating
where to find the applicable terms.
Additional terms, permissive or non-permissive, may be stated in the
form of a separately written license, or stated as exceptions;
the above requirements apply either way.
8. Termination.
You may not propagate or modify a covered work except as expressly
provided under this License. Any attempt otherwise to propagate or
modify it is void, and will automatically terminate your rights under
this License (including any patent licenses granted under the third
paragraph of section 11).
However, if you cease all violation of this License, then your
license from a particular copyright holder is reinstated (a)
provisionally, unless and until the copyright holder explicitly and
finally terminates your license, and (b) permanently, if the copyright
holder fails to notify you of the violation by some reasonable means
prior to 60 days after the cessation.
Moreover, your license from a particular copyright holder is
reinstated permanently if the copyright holder notifies you of the
violation by some reasonable means, this is the first time you have
received notice of violation of this License (for any work) from that
copyright holder, and you cure the violation prior to 30 days after
your receipt of the notice.
Termination of your rights under this section does not terminate the
licenses of parties who have received copies or rights from you under
this License. If your rights have been terminated and not permanently
reinstated, you do not qualify to receive new licenses for the same
material under section 10.
9. Acceptance Not Required for Having Copies.
You are not required to accept this License in order to receive or
run a copy of the Program. Ancillary propagation of a covered work
occurring solely as a consequence of using peer-to-peer transmission
to receive a copy likewise does not require acceptance. However,
nothing other than this License grants you permission to propagate or
modify any covered work. These actions infringe copyright if you do
not accept this License. Therefore, by modifying or propagating a
covered work, you indicate your acceptance of this License to do so.
10. Automatic Licensing of Downstream Recipients.
Each time you convey a covered work, the recipient automatically
receives a license from the original licensors, to run, modify and
propagate that work, subject to this License. You are not responsible
for enforcing compliance by third parties with this License.
An "entity transaction" is a transaction transferring control of an
organization, or substantially all assets of one, or subdividing an
organization, or merging organizations. If propagation of a covered
work results from an entity transaction, each party to that
transaction who receives a copy of the work also receives whatever
licenses to the work the party's predecessor in interest had or could
give under the previous paragraph, plus a right to possession of the
Corresponding Source of the work from the predecessor in interest, if
the predecessor has it or can get it with reasonable efforts.
You may not impose any further restrictions on the exercise of the
rights granted or affirmed under this License. For example, you may
not impose a license fee, royalty, or other charge for exercise of
rights granted under this License, and you may not initiate litigation
(including a cross-claim or counterclaim in a lawsuit) alleging that
any patent claim is infringed by making, using, selling, offering for
sale, or importing the Program or any portion of it.
11. Patents.
A "contributor" is a copyright holder who authorizes use under this
License of the Program or a work on which the Program is based. The
work thus licensed is called the contributor's "contributor version".
A contributor's "essential patent claims" are all patent claims
owned or controlled by the contributor, whether already acquired or
hereafter acquired, that would be infringed by some manner, permitted
by this License, of making, using, or selling its contributor version,
but do not include claims that would be infringed only as a
consequence of further modification of the contributor version. For
purposes of this definition, "control" includes the right to grant
patent sublicenses in a manner consistent with the requirements of
this License.
Each contributor grants you a non-exclusive, worldwide, royalty-free
patent license under the contributor's essential patent claims, to
make, use, sell, offer for sale, import and otherwise run, modify and
propagate the contents of its contributor version.
In the following three paragraphs, a "patent license" is any express
agreement or commitment, however denominated, not to enforce a patent
(such as an express permission to practice a patent or covenant not to
sue for patent infringement). To "grant" such a patent license to a
party means to make such an agreement or commitment not to enforce a
patent against the party.
If you convey a covered work, knowingly relying on a patent license,
and the Corresponding Source of the work is not available for anyone
to copy, free of charge and under the terms of this License, through a
publicly available network server or other readily accessible means,
then you must either (1) cause the Corresponding Source to be so
available, or (2) arrange to deprive yourself of the benefit of the
patent license for this particular work, or (3) arrange, in a manner
consistent with the requirements of this License, to extend the patent
license to downstream recipients. "Knowingly relying" means you have
actual knowledge that, but for the patent license, your conveying the
covered work in a country, or your recipient's use of the covered work
in a country, would infringe one or more identifiable patents in that
country that you have reason to believe are valid.
If, pursuant to or in connection with a single transaction or
arrangement, you convey, or propagate by procuring conveyance of, a
covered work, and grant a patent license to some of the parties
receiving the covered work authorizing them to use, propagate, modify
or convey a specific copy of the covered work, then the patent license
you grant is automatically extended to all recipients of the covered
work and works based on it.
A patent license is "discriminatory" if it does not include within
the scope of its coverage, prohibits the exercise of, or is
conditioned on the non-exercise of one or more of the rights that are
specifically granted under this License. You may not convey a covered
work if you are a party to an arrangement with a third party that is
in the business of distributing software, under which you make payment
to the third party based on the extent of your activity of conveying
the work, and under which the third party grants, to any of the
parties who would receive the covered work from you, a discriminatory
patent license (a) in connection with copies of the covered work
conveyed by you (or copies made from those copies), or (b) primarily
for and in connection with specific products or compilations that
contain the covered work, unless you entered into that arrangement,
or that patent license was granted, prior to 28 March 2007.
Nothing in this License shall be construed as excluding or limiting
any implied license or other defenses to infringement that may
otherwise be available to you under applicable patent law.
12. No Surrender of Others' Freedom.
If conditions are imposed on you (whether by court order, agreement or
otherwise) that contradict the conditions of this License, they do not
excuse you from the conditions of this License. If you cannot convey a
covered work so as to satisfy simultaneously your obligations under this
License and any other pertinent obligations, then as a consequence you may
not convey it at all. For example, if you agree to terms that obligate you
to collect a royalty for further conveying from those to whom you convey
the Program, the only way you could satisfy both those terms and this
License would be to refrain entirely from conveying the Program.
13. Use with the GNU Affero General Public License.
Notwithstanding any other provision of this License, you have
permission to link or combine any covered work with a work licensed
under version 3 of the GNU Affero General Public License into a single
combined work, and to convey the resulting work. The terms of this
License will continue to apply to the part which is the covered work,
but the special requirements of the GNU Affero General Public License,
section 13, concerning interaction through a network will apply to the
combination as such.
14. Revised Versions of this License.
The Free Software Foundation may publish revised and/or new versions of
the GNU General Public License from time to time. Such new versions will
be similar in spirit to the present version, but may differ in detail to
address new problems or concerns.
Each version is given a distinguishing version number. If the
Program specifies that a certain numbered version of the GNU General
Public License "or any later version" applies to it, you have the
option of following the terms and conditions either of that numbered
version or of any later version published by the Free Software
Foundation. If the Program does not specify a version number of the
GNU General Public License, you may choose any version ever published
by the Free Software Foundation.
If the Program specifies that a proxy can decide which future
versions of the GNU General Public License can be used, that proxy's
public statement of acceptance of a version permanently authorizes you
to choose that version for the Program.
Later license versions may give you additional or different
permissions. However, no additional obligations are imposed on any
author or copyright holder as a result of your choosing to follow a
later version.
15. Disclaimer of Warranty.
THERE IS NO WARRANTY FOR THE PROGRAM, TO THE EXTENT PERMITTED BY
APPLICABLE LAW. EXCEPT WHEN OTHERWISE STATED IN WRITING THE COPYRIGHT
HOLDERS AND/OR OTHER PARTIES PROVIDE THE PROGRAM "AS IS" WITHOUT WARRANTY
OF ANY KIND, EITHER EXPRESSED OR IMPLIED, INCLUDING, BUT NOT LIMITED TO,
THE IMPLIED WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR
PURPOSE. THE ENTIRE RISK AS TO THE QUALITY AND PERFORMANCE OF THE PROGRAM
IS WITH YOU. SHOULD THE PROGRAM PROVE DEFECTIVE, YOU ASSUME THE COST OF
ALL NECESSARY SERVICING, REPAIR OR CORRECTION.
16. Limitation of Liability.
IN NO EVENT UNLESS REQUIRED BY APPLICABLE LAW OR AGREED TO IN WRITING
WILL ANY COPYRIGHT HOLDER, OR ANY OTHER PARTY WHO MODIFIES AND/OR CONVEYS
THE PROGRAM AS PERMITTED ABOVE, BE LIABLE TO YOU FOR DAMAGES, INCLUDING ANY
GENERAL, SPECIAL, INCIDENTAL OR CONSEQUENTIAL DAMAGES ARISING OUT OF THE
USE OR INABILITY TO USE THE PROGRAM (INCLUDING BUT NOT LIMITED TO LOSS OF
DATA OR DATA BEING RENDERED INACCURATE OR LOSSES SUSTAINED BY YOU OR THIRD
PARTIES OR A FAILURE OF THE PROGRAM TO OPERATE WITH ANY OTHER PROGRAMS),
EVEN IF SUCH HOLDER OR OTHER PARTY HAS BEEN ADVISED OF THE POSSIBILITY OF
SUCH DAMAGES.
17. Interpretation of Sections 15 and 16.
If the disclaimer of warranty and limitation of liability provided
above cannot be given local legal effect according to their terms,
reviewing courts shall apply local law that most closely approximates
an absolute waiver of all civil liability in connection with the
Program, unless a warranty or assumption of liability accompanies a
copy of the Program in return for a fee.
END OF TERMS AND CONDITIONS
How to Apply These Terms to Your New Programs
If you develop a new program, and you want it to be of the greatest
possible use to the public, the best way to achieve this is to make it
free software which everyone can redistribute and change under these terms.
To do so, attach the following notices to the program. It is safest
to attach them to the start of each source file to most effectively
state the exclusion of warranty; and each file should have at least
the "copyright" line and a pointer to where the full notice is found.
Copyright (C)
This program is free software: you can redistribute it and/or modify
it under the terms of the GNU General Public License as published by
the Free Software Foundation, either version 3 of the License, or
(at your option) any later version.
This program is distributed in the hope that it will be useful,
but WITHOUT ANY WARRANTY; without even the implied warranty of
MERCHANTABILITY or FITNESS FOR A PARTICULAR PURPOSE. See the
GNU General Public License for more details.
You should have received a copy of the GNU General Public License
along with this program. If not, see .
Also add information on how to contact you by electronic and paper mail.
If the program does terminal interaction, make it output a short
notice like this when it starts in an interactive mode:
Copyright (C)
This program comes with ABSOLUTELY NO WARRANTY; for details type `show w'.
This is free software, and you are welcome to redistribute it
under certain conditions; type `show c' for details.
The hypothetical commands `show w' and `show c' should show the appropriate
parts of the General Public License. Of course, your program's commands
might be different; for a GUI interface, you would use an "about box".
You should also get your employer (if you work as a programmer) or school,
if any, to sign a "copyright disclaimer" for the program, if necessary.
For more information on this, and how to apply and follow the GNU GPL, see
.
The GNU General Public License does not permit incorporating your program
into proprietary programs. If your program is a subroutine library, you
may consider it more useful to permit linking proprietary applications with
the library. If this is what you want to do, use the GNU Lesser General
Public License instead of this License. But first, please read
.
tt/CREDITS 0000664 0601750 0601001 00000003702 13540246775 012003 0 ustar eigenaar None Special thanks to the following
-----------------------------------------------------------------------------
1992-1992 Peter Joachim Unold see mods/0.3.mods The original TINTIN III
1993-1995 Bill Reiss see mods/1.5.mods Original #math code
Jeremy C. Jack see mods/1.5.mods
David A. Wagner see mods/1.5.mods
Joann Ellsworth see mods/1.5.mods Original manual
David Hedbot Original GNU autoconfig
Greg Jarman Original #if code
1997-1998 Peter Kjellerstedt see mods/1.8.mods
1998-1998 Sean Butler see mods/1.8.mods Original #chat code
1998-1999 Sverre Norrman see mods/1.8.mods Original #function code
1998-1999 Robert Ellsworth see mods/1.8.mods
1999-2001 Davin Chan see mods/1.8.mods
2004-2019 Igor van den Hoven see mods/igr.mods
Bryan Turner Map search enhancement
David Champion Solaris forkpty fix
Ben Love Tab enhancements
Adam Borowski SSL implementation
Beta Testers
-----------------------------------------------------------------------------
Unfortunately (or fortunately) there are too many to list, but your help has
been greatly appreciated. You are invaluable to TinTin++'s continued success.
Thanks!
Modification History
-----------------------------------------------------------------------------
0.3.mods apr 1992 - oct 1992
1.5.mods jun 1993 - jan 1995
1.8.mods apr 1997 - oct 2001
igr.mods feb 2004
TinTin++ Developer
-----------------------------------------------------------------------------
Igor van den Hoven - mudclient@gmail.com
The email must contain either tintin or tintin++ in the subject or message,
otherwise it will not get forwarded to my main email account.
tt/docs/ 0000750 0601750 0601001 00000000000 13656647042 011702 5 ustar eigenaar None tt/docs/chat_protocol.txt 0000664 0601750 0601001 00000020435 13537151322 015303 0 ustar eigenaar None Mud Master Chat Protocol
Establishing a Connection
Caller: Once a connection is made the caller sends a connection string;
which looks like: "CHAT:\n". The sprintf
syntax is: "CHAT:%s\n%s%-5u". The port must be 5 characters, padded on the
right side with spaces. Once this string has been sent it waits for a
response from the other side. If a "NO" is received the call is cancelled.
If the call was accepted the string "YES:\n" is received.
Receiver
When a socket call is detected it accepts the socket then waits
for the "CHAT:" string to be send from the caller. If the receiver wishes
to deny the call, the string "NO" needs to be sent back to the caller. To
accept the call, the string "YES:\n" is sent back.
Chat Data Blocks
A chat data block looks like this: .
All data dealing with needs to follow this format with a couple exceptions.
The connection process doesn't use the data blocks and the file transfer
blocks are a fixed size and don't need the byte.
Default Port
The default port should always be 4050.
Below is a list of the values:
#define CHAT_NAME_CHANGE 1
#define CHAT_REQUEST_CONNECTIONS 2
#define CHAT_CONNECTION_LIST 3
#define CHAT_TEXT_EVERYBODY 4
#define CHAT_TEXT_PERSONAL 5
#define CHAT_TEXT_GROUP 6
#define CHAT_MESSAGE 7
#define CHAT_DO_NOT_DISTURB 8
#define CHAT_VERSION 19
#define CHAT_FILE_START 20
#define CHAT_FILE_DENY 21
#define CHAT_FILE_BLOCK_REQUEST 22
#define CHAT_FILE_BLOCK 23
#define CHAT_FILE_END 24
#define CHAT_FILE_CANCEL 25
#define CHAT_PING_REQUEST 26
#define CHAT_PING_RESPONSE 27
#define CHAT_PEEK_CONNECTIONS 28
#define CHAT_PEEK_LIST 29
#define CHAT_SNOOP_START 30
#define CHAT_SNOOP_DATA 31
#define CHAT_END_OF_COMMAND 255
The byte is 255:
When a user changes their chat name the new name needs to be broadcast to
all of their connections.
The sender requests connections from another connection asking to see all the
people that person has marked as public, then try to connect to all of those
yourself.
,,,
The receiver needs to put all the ip addresses and port numbers in a comma
delimited string and send them back as a connection list.
Used to send some chat text to everybody. All the text you want to be
displayed needs to be generated on the sender's side, including the line
feeds and the " chats to everybody" string.
Receiver:
If the chat connection isn't being ignored, you simply print the
string. If you have any connections marked as being served you need to echo
this string to those connections. Or if this is coming from a connection
being served, you need to echo to all your other connections. This allows
people who cannot connect directly to each other to connect with a 3rd
person who *can* connect to both and be a server for them.
This works the same way as CHAT_TEXT_EVERYBODY as far as what you need to
send. The text should obviously be changed so the person receiving knows
this was a personal chat and not broadcast to everybody. "\n%s chats to
you, '%s'\n"
Receiver:
Just print the string that comes in if you aren't ignoring this connection.
Used when you send text to a specific group of connections. Works basically
the same as the other text commands. The group name is a 15 character
string. It *must* be 15 characters long, pad it on the right with spaces
to fill it out. "\n%s chats to the group, '%s'\n"
Receiver:
Just print the string that comes in if you aren't ignoring this
connection.
This is used to send a message to another chat connection. An example of
this is when you try to send a command (action, alias, etc) to another chat
connection and they don't have you flagged as accepting commands. In that
case a chat message is sent back to the sender telling them that command are
not being accepted. To let the other side know the message is generated
from the chat program it is a good idea to make the string resemble
something like: "\n %s is not allowing commands.\n"
Receiver: Just print the message string.
This is used to send your client's name and version.
This is sent to start sending a chat connection a file. The filename should
be just the filename and not a path. Length is the size of the file in
bytes.
Receiver:
First should check to make sure you are allowing files from this
connection. Make sure the filename is valid and that the length was
trasnmitted. MM by default won't allow you to overwrite files; which keeps
people from messing with file already in your directory. If for any reason
the data isn't valid or you don't want to accept files from this person a
CHAT_FILE_DENY should be sent back to abort the transfer. If you want to
continue with the transfer you need to start it off by requesting a block of
data with CHAT_FILE_BLOCK_REQUEST.
This is used when a CHAT_FILE_START has been received and you want to
prevent the transfer from continuing. is a string telling the
reason it was denied. For example, if the file already existed you might
deny it with: "File already exists."
Receiver:
Print the deny message. Deal with cleaning up any files you
opened when you tried to start the transfer.
Sent to request the next block of data in a transfer.
Receiver:
Need to create a file block to be sent back. File blocks are
fixed length so they don't need the CHAT_END_OF_COMMAND byte. If the end of
file is reached need to send a CHAT_FILE_END close up the files and let the
user know it is done sending.
A file block is 500 bytes. A file block is ALWAYS 500 bytes so no CHAT_END_OF_COMMAND should be added.
Receiver:
The receiver needs to keep track of the number of bytes written to
properly write the last block of data. If you keep track of the bytes
written you know when to expect that last block that probably doesn't have a
full 500 bytes to be saved. File transfers are receiver driven, so for each
block of data you accept, you need to send another CHAT_FILE_BLOCK_REQUEST
back out to get more data.
Close up your files and be done with it. This command isn't required for TinTin since it keeps track of the file transfer progress itself.
Either side can send this command to abort a file transfer in progress.
The timing data is up to the ping requester. TinTin sends a 64 bit time stamp.
Send back the timing data is the data that was sent with the CHAT_PING_REQUEST.
The sender requests connections from another connection asking to see all the
people that person has marked as public.
~~~
The receiver needs to put all the ip addresses, port numbers, and names in a
tilda delimited string and send them back as a peek list.
The sender requests to start or stop snooping data from a chat connection.
The Receiver decides whether to allow snooping or not.
Send by a client in snoop or forward mode. The message should be echoed by
the receiver, but not be further forwarded to avoid infinite loops. tt/docs/help.html 0000664 0601750 0601001 00000673544 13657035010 013535 0 ustar eigenaar None
ACTION ALIAS ALL BELL BREAK BUFFER BUTTON CASE CAT CHARACTERS CHAT CLASS COLORS COMMANDS COORDINATES CONFIG CONTINUE CR CURSOR DAEMON DEBUG DEFAULT DELAY DRAW ECHO ELSE ELSEIF END ESCAPE CODES EVENT FOREACH FORMAT FUNCTION GAG GREETING GREP HELP HIGHLIGHT HISTORY IF IGNORE INDEX INFO KEYPAD KILL LINE LIST LISTS LOCAL LOG LOOP MACRO MAP MAPPING MATH MATHEMATICS MESSAGE METRIC SYSTEM MSDP MSLP NOP PARSE PATH PATHDIR PCRE PORT PROMPT READ REGEXP REPEAT REPLACE RETURN RUN SCAN SCREEN SCREEN READER SCRIPT SEND SESSION SESSIONNAME SHOWME SNOOP SPEEDWALK SPLIT SSL STATEMENTS SUBSTITUTE SUSPEND SWITCH SYSTEM TAB TEXTIN TICKER TIME VARIABLE WHILE WRITE ZAP ACTION
Command: #action {message} {commands} {priority}
The #action command can be used to respond with one or several
commands to a specific message send by the server. The %1-%99
variables are substituted from the message and can be used in the
command part of the action.
The priority part is optional and determines the priority of the
action, it defaults to 5.
If the message starts with a ~ color codes must be matched. You can
enable #config {convert meta} on to display meta characters.
For more information on pattern matching see the section on PCRE.
Example: #action {%1 tells you '%2'} {tell %1 I'm afk.}
Actions can be triggered by the show command and certain system
messages.
Actions can be triggered by the #show command. If you don't want a
#show to get triggered use: #line ignore #show {text}
Actions are ordered alphabetically and only one action can trigger at
a time. To change the order you can assign a priority, which defaults
to 5, with a lower number indicating a higher priority. The priority
can be a floating point number.
To remove action with %* as the message, use #unaction {%%*} or
#unaction {%*}. Alternatively you could wrap the action inside a
class, and kill that class when you no longer need the action.
Comment: You can remove an action with the #unaction command.
Related: pcre, gag, highlight, prompt and substitute.
ALIAS
Command: #alias {name} {commands} {priority}
The #alias command can be used to shorten up long or oftenly used
commands. The %1-99 variables are substituted from the arguments when
using an alias and represent the 1st till 99th word which can be used
in the commands part of the alias. If %0 is used it will contain all
arguments. The priority part is optional and determines the priority
of the alias, it defaults to 5.
Example: #alias {k} {kill %1;kick}
Typing 'k orc' would result in attacking the orc followed by a kick.
You can create multi-word aliases by using variables in the name
section.
Example: #alias {k %1 with %2} {draw %2;attack %1;slash %1 with %2;
kick at %2;strike %1 with %2}
Using the above alias you could type k blue smurf with battle axe
To have an alias that matches all user input, use %* as the name.
Example: #alias {%*} {#show You wrote: %0}
Aliases are ordered alphabetically and only one alias can trigger at
a time. To change the order you can assign a priority, which defaults
to 5, with a lower number indicating a higher priority. The priority
can be a floating point number.
To remove an alias with %* as the name, use #unalias {%%*} or #unalias
{%*}. Alternatively you can wrap the alias inside a class, and kill
that class when you no longer need the alias.
For more information on pattern matching see the section on PCRE.
Comment: You can remove an alias with the #unalias command.
Related: cursor, history, keypad, macro, speedwalk and tab.
ALL
Command: #all {string}
If you have multiple sessions in one terminal you can use #all to
execute the command with all sessions, excluding the startup session.
Example: #all quit
Sends 'quit' to all sessions.
Related: port, run, session, sessionname, snoop, ssl and zap.
BELL
Command: #bell {flash|focus|margin|ring|volume} {argument}
The #bell command without an argument will ring the terminal bell.
Example: #action {Bubba tells you} {#bell}
If you aren't watching the screen this could be useful if you don't
want to miss out on a conversation with Bubba. Alternatively you can
use #system to play a sound file.
Some terminals will allow you to use VT100 Operating System Commands
to change the terminal's bell behavior which can be used to flash the
taskbar icon and or focus the window on receival of a bell.
Example: #action {Bubba tells you} {#screen save title;#screen set title Tell!;
#bell ring;#delay 10 #screen load title}
The above example will save your window title, change the title to
'Tell!', ring the bell, next reset the window title after 10 seconds.
It's possible to set the terminal to pop to the foreground upon
ringing of the alarm bell.
Example: #bell focus on;#bell ring;#bell focus off
It's possible to adjust the alarm bell volume on some terminals.
Example: #loop {1} {8} {cnt} {#line substitute variables
#delay {$cnt} {#show Volume $cnt: #bell volume $cnt;#bell}
Related: screen BREAK
Command: #break
The break command can be used inside the #foreach, #loop, #parse,
#while and #switch statements. When #break is found, tintin will stop
executing the statement it is currently in and move on to the next.
Example: #while {1} {#math cnt $cnt + 1;#if {$cnt == 20} {#break}}
Related: statements BUFFER
Command: #buffer {home|up|down|end|lock|find|get|clear}
The buffer command has various options to manipulate your scrollback
buffer.
#buffer {home}
Moves you to the top of your scrollback buffer and displays the page.
Enables scroll lock mode. Most useful when used in a #macro.
#buffer {up} [lines]
Moves your scrollback buffer up one page and displays the page.
Enables scroll lock mode. Most useful when used in a #macro. You
can use #buffer {up} {1} to move the scrollback buffer up 1 line.
#buffer {down} [lines]
Moves your scrollback buffer down one page and displays the page.
Enables scroll lock mode unless at the end. Most useful when used in
a #macro.
#buffer {end}
Moves you to the end of your scrollback buffer and displays the page.
Disables scroll lock mode. Most useful when used in a #macro.
#buffer {find} {[number]} {<string>}
Moves the buffer to the given string which can contain a regular
expression. Optionally you can provide the number of matches to skip,
allowing you to jump further back in the buffer.
#buffer {get} {<variable>} {<lower bound>} {[upper bound]}
Allows you to store one or several lines from your scrollback buffer
(including color codes) into a variable. The lower and upper bound
must be between 1 and the size of the buffer. If the upper bound is
omitted the given line is stored as a standard variable. If an upper
bound is given the lines between the two bounds are stored as a list.
#buffer {lock} {on|off}
Toggles the lock on the scrollback buffer. When locked, newly incoming
text won't be displayed, any command will disable the lock, though
several buffer commands will re-enable the lock. When unlocking it'll
move you to the end of your scrollback buffer and display the page.
#buffer {write} {<filename>}
Writes the scrollback buffer to the given file.
Example: #macro {\e[F} {#buffer end}
Related: echo, grep, macro, showme and screen.
BUTTON
Command: #button {square} {commands} {priority}
The #button command can be used to respond with one or several
commands to a mouse click received within the specified square.
The click coordinates are stored in %0-%3 and can be used in the
command part of the button.
The square part should exists of two coordinates defining the
upper left and bottom right corner using row, col, row, col syntax.
The square arguments should be separated by spaces, semi-colons or
braces.
By default the button is set to respond to a mouse button press, to
respond to other button presses you must add a 5th argument to the
square that defines the button press type. You can enable #info
button on to see button events and their type as they happen.
The priority part is optional and determines the priority of the
button, it defaults to 5.
You must enable #config {mouse tracking} on for buttons to work.
This command draws no visible button, you'll have to do so separately
if needed.
Example: #button {1;1;2;2} {#show You clicked the upper left corner.}
Buttons are ordered alphabetically and only one button can trigger at
a time. To change the order you can assign a priority, which defaults
to 5, with a lower number indicating a higher priority. The priority
can be a floating point number.
Comment: To see button clicks trigger use #info button on.
Comment: You can remove a button with the #unbutton command.
Related: delay, event and ticker.
CASE
Command: #case {conditional} {arguments}
The case command must be used within the #switch command. When the
conditional argument of the case command matches the conditional
argument of the switch command the body of the case is executed.
When comparing strings both the switch and case arguments must be
surrounded in quotes.
Example:
#function {reverse_direction}
{
#switch {"%1"}
{
#case {"north"} {#return south};
#case {"east"} {#return west};
#case {"south"} {#return north};
#case {"west"} {#return east};
#case {"up"} {#return down};
#case {"down"} {#return up}
}
}
This function returns the reverse direction. @reverse_direction{north}
would return south.
Related: default, statements and switch.
CAT
Command: #cat {variable} {argument}
The cat command will concatinate the argument to the given variable.
Related: format, function, local, math, replace, script and variable.
CHARACTERS
The following special characters are defined:
# The hashtag is the default character for starting a command and is
subsequently known as the command character or tintin character.
When loading a command file the command character is set to the
first character in the file. The character can also be redefined
using #config.
; The semi-colon is used as the command separator and can be used to
separate two commands. Multiple commands can be strung together as
well. Trailing semi-colons are ignored when reading a script file
as this is a common error.
{ } Curly brackets aka braces are used for separating multi word command
arguments, nesting commands, and nesting variables. Braces cannot
easily be escaped and must always be used in pairs.
" " Quote characters are used for strings in the #math, #if, #switch,
and #case commands. It is however suggested to use an extra
set of braces { } to define strings.
! The exclamation sign is used to repeat commands, see #help history.
The character can be redefined using #config.
\ An input line starting with a backslash is send verbatim if you are
connected to a server. This character can be configured with
#config.
Related: colors, escape, mathematics and pcre.
CHAT
Command: #chat {option} {argument}
The #chat command is used to create peer to peer connections to other
clients, typically for the purpose of chatting and sending files.
This is a decentralized chat system, meaning you have to exchange ip
addresses and port numbers with other users in order to connect to
them.
#chat {init} {port}
#chat initialize launches your chat server. The port number is
optional, and by default 4050 is used as your port. After using
this command other people can connect to your chat server using
your ip address and port number, and in turn you can connect to
other people.
#chat {name} {name}
By default your name is set to TinTin, but most servers will
reject you if there is already someone with the name TinTin
connected, so one of the first things you'd want to do is
change your chat name. Your name can include color codes. Some
names aren't accepted by tt++ chat servers, like the name 'all'
and names longer than 20 characters.
#chat {message} {buddy|all} {text}
This is the main command used for communication. If you use
#chat message all, the message is marked as public and send to
everyone you are connected to.
#chat {accept} {buddy} {boost}
Accept a file transfer from a buddy. The boost is optional and
must be a value between 1 and 1000.
#chat {call} {address} {port}
#chat call is used to connect to another chat server. If you
omit the port argument the default port (4050) is used.
#chat {cancel} {buddy} Cancel a file transfer
#chat {color} {color names} Set the default color
#chat {decline} {buddy} Decline a file transfer
#chat {dnd} Decline new connections
#chat {download} {directory} Set your download directory
#chat {emote} {buddy|all} {text} Send an emote message
#chat {forward} {buddy} Forward all chat messages
#chat {forwardall} {buddy} Forward all session output
#chat {filestat} {buddy} Show file transfer data
#chat {group} {buddy} {name} Assign a chat group
#chat {ignore} {buddy} Ignores someone
#chat {info} Displays your info
#chat {ip} {address} Changes your IP address
#chat {paste} {buddy|all} {text} Pastes a block of text
#chat {peek} {buddy} Show one's public connections
#chat {ping} {buddy} Display response time
#chat {private} {buddy|all} Make a connection private
#chat {public} {buddy|all} Make a connection public
#chat {reply} {text} Reply to last private message
#chat {request} {buddy} Request one's public connections
#chat {send} {buddy|all} {text} Sends a raw data string
#chat {sendfile} {buddy} {filename} Start a file transfer
#chat {serve} {buddy} Forward all public chat messages
#chat {uninitialize} Uninitialize the chat port.
#chat {who} Show all connections
#chat who shows all people you are connected to. The first
column shows a reference number for the connection, which can be
used instead of the connection's name when sending someone a message
The second column shows the connection's name. The third column
shows flags set for the connection, (P)rivate, (I)gnore, (S)erve,
(F)orward to user, and (f)orward from user. The next columns show
ip, port, and client name.
#chat {zap} {buddy} Close a connection
Related: port CLASS
Command: #class {name} {optionkill} {arg}#class {<name>} {open}
Open a class, closing a previously opened class. All triggers
added afterwards are assigned to this class.
#class {<name>} {clear}
Will delete all triggers associated with the given class.
#class {<name>} {close}
Close the given class, opening the last open class, if any.
#class {<name>} {kill}
Will clear, close, and remove the class.
#class {<name>} {list}
List all triggers associated with the given class.
#class {<name>} {load}
Will load the saved copy of the class from memory.
#class {<name>} {read} {<filename>
Will open the class, read the file, and close afterwards.
#class {<name>} {save}
Will save all triggers of the given class to memory.
#class {<name>} {size} {<variable>}
Will store the size of the class in a variable.
#class {<name>} {write} {<filename>}
Will write all triggers of the given class to file.
The {kill} option will delete all triggers of the given class.
Keep in mind that the kill and read option are very fast allowing
them to be used to enable and disable classes.
Example: #class extra kill;#class extra read extra.tin
Deletes all triggers of 'extra' class if any. Read 'extra.tin' file,
all triggers loaded will be assigned to the fresh new 'extra' class.
Related: config, debug, ignore, info, kill, line and message.
COLORS
Syntax: <xyz> with x, y, z being parameters
Parameter 'x': VT100 code
0 - Reset all colors and codes to default
1 - Bold
2 - Dim
4 - Underscore
5 - Blink
7 - Reverse
8 - Skip (use previous code)
Parameter 'y': Foreground color
Parameter 'z': Background color
0 - Black 5 - Magenta
1 - Red 6 - Cyan
2 - Green 7 - White
3 - Yellow 8 - Skip
4 - Blue 9 - Default
For xterm 256 colors support use <aaa> to <fff> for RGB foreground
colors and <AAA> to <FFF> for RGB background colors. For the grayscale
foreground colors use <g00> to <g23>, for grayscale background colors
use <G00> to <G23>.
The tertiary colors are as follows:
<acf> - Azure <afc> - Jade
<caf> - Violet <cfa> - Lime
<fac> - Pink <fca> - Orange
Example: #show <acf>Azure <afc>Jade <caf>Violet
Example: #show <cfa>Lime <fac>Pink <fca>Orange
For 12 bit truecolor use <F000> to <FFFF> for foreground colors and
<B000> to <BFFF> for background colors.
For 24 bit truecolor use <F000000> to <FFFFFFF> for foreground
colors and <B000000> to <BFFFFFF> for background colors.
If the color code exceeds your configured color mode it will be
downgraded to the closest match.
Related: characters, coordinates, escape, mathematics and pcre.
COMMANDS
Command: #commands {regex}
Shows all commands or all commands matching the given search
string.
Related: help, info and statements.
COORDINATES
When the 0,0 coordinate is in the upper left corner TinTin++ uses
a y,x / rows,cols notation. When the 0,0 coordinate is in the
bottom left corner tintin uses a x,y / cols/rows notation.
When a square is defined this is done by specifying the upper left
and bottom right corner of the square using four coordinates.
The vast majority of tintin commands use row,col notation.
Related: characters, colors, escape, mathematics and pcre.
CONFIG
Command: #config {option} {argument}
This allows you to configure various settings, the settings can be
written to file with the #write command.
If you configure the global session (the one you see as you start up
tintin) all sessions started will inherite these settings.
It's advised to make a configuration file to read on startup if you
do not like the default settings.
Config options which aren't listed by default:
#CONFIG {BUFFER SIZE} {SIZE} Set the scrollback buffer size.
#CONFIG {CHILD LOCK} {ON|OFF} Enable or disable command input.
#CONFIG {CONVERT META} {ON|OFF} Shows color codes and key bindings.
#CONFIG {DEBUG TELNET} {ON|OFF} Shows telnet negotiations y/n.
#CONFIG {LOG LEVEL} {LOW|HIGH} LOW logs server output before triggers.
#CONFIG {INHERITANCE} {ON|OFF} Session trigger inheritance y/n.
#CONFIG {MCCP} {ON|OFF} Enable or disable MCCP support.
#CONFIG {PID} {NUMBER} Set the PID of the master process.
Related: class and line.
CONTINUE
Command: #continue
The continue command can be used inside the #FOREACH, #LOOP, #PARSE,
#WHILE and #SWITCH commands. When #CONTINUE is found, tintin will go
to the end of the command and proceed as normal, which may be to
reiterate the command.
Example: #loop 1 10 cnt {#if {$cnt % 2 == 0} {#continue} {say $cnt}}
Related: break, foreach, list, loop, parse, repeat, return and while.
CR
Command: #cr
Sends a carriage return to the session. Useful for aliases that need
extra carriage returns.
This command is obsolete as you can accomplish the same using #send
without an argument or #send {}.
Related: forall CURSOR
Command: #cursor {option} {argument}
Typing #cursor without an option will show all available cursor
options, their default binding, and an explanation of their function.
The cursor command's primarly goal is adding customizable input editing
with macros. Subsequently many cursor commands only work properly when
used within a macro or event.
#cursor tab <list;scrollback> <backward|forward>
Tab through the given option(s) going forward or backward.
Related: alias, history, keypad, macro, speedwalk and tab.
DAEMON
Command: #daemon {attach|detach|kill|list} [name]
#daemon provides functionality similar to that of the screen and tmux
utilities.
#daemon attach [name]
The attach option will try to find a daemonized tintin instance and
take over control. The name argument is optional.
#daemon detach [name]
The detach option will daemonize tintin, turning it into a background
process. The name argument is optional and is useful if you have
several daemonized tt++ instances running so you can keep them apart.
#daemon kill [name]
Kills all daemons or daemons with matching name.
#daemon list [name]
List all daemons or daemons with matching name.
Related: script, system and run.
DEBUG
Command: #debug {listname} {on|off|log}
Toggles a list on or off. With no argument it shows your current
settings, as well as the list names that you can debug.
If you for example set ACTIONS to ON you will get debug information
whenever an action is triggered.
#debug {listname} {log} will silently write debugging information to
the log file, you must be logging in order for this to work.
Not every list has debug support yet.
Related: class, ignore, info, kill and message.
DEFAULT
Command: #default {commands}
The default command can only be used within the switch command. When
the conditional argument of non of the case commands matches the switch
command's conditional statement the default command is executed.
Related: case, default, else, elseif, if, switch and regexp.
DELAY
Command: #delay {seconds} {command}Command: #delay {name} {command} {seconds}
Delay allows you to have tintin wait the given amount of seconds
before executing the given command. tintin won't wait before
executing following input commands if any.
Floating point precision for milliseconds is possible.
Example: #show first;#delay {1} {#show last}
This will print 'first', and 'last' around one second later.
Comment: If you want to remove a delay with the #undelay command you can add
a name as the first argument, be aware this changes the syntax. If
the name is a number keep in mind that delays with the same numeric
name will not be overwritten
Related: event and ticker.
DRAW
Command: #draw [color] [options] <type> <square> {text}
The draw commands allows you to draw various types of lines and shapes
on the screen. Common options and types with a brief description are
provided when you type #draw without an argument.
The square arguments should exists of two coordinates defining the
upper left and bottom right corner using row, col, row, col syntax.
You can prefix the option with a color code or color name to color the
lines and shapes.
You can further prefix the option as following:
ASCII will draw in ASCII mode.
BLANKED will blank the lines and corners.
BOLD will draw text with bold letters.
BOTTOM will draw on the bottom side if possible.
BUMPED will precede the draw with an enter.
CIRCLED will circle the corners.
CONVERT will draw text with meta conversion.
CROSSED will cross the corners.
CURSIVE will draw text with cursive letters.
FAT will draw text with fat letters.
FILLED will fill circles and jewels.
GRID will draw TABLE as a grid.
HORIZONTAL will draw horizontal if possible.
HUGE will draw text in huge letters.
JEWELED will diamond the corners.
JOINTED will draw corners.
LEFT will draw on the left side if possible.
NUMBERED will draw numbered, mostly for debugging.
PRUNED will prune the corners.
RIGHT will draw on the right side if possible.
ROUNDED will round the corners.
SCROLL will draw in the scrolling region.
SHADOWED will shadow HUGE text.
TEED will tee the corners.
TRACED will trace HUGE text.
TOP will draw on the top side if possible.
TUBED will draw tubes instead of lines.
UNICODE will draw in unicode mode.
VERTICAL will draw vertical if possible.
The following types are available.
[ASCII|UNICODE|HUGE] BOX {[TEXT1]} {[TEXT2]}
will draw a box.
[BLANKED|CIRCLED|CROSSED|JEWELED|ROUNDED|TEED|PRUNED] CORNER
will draw a corner.
[BLANKED|HORIZONTAL|NUMBERED|TUBED|VERTICAL] LINE {[TEXT]}
will draw a line.
RAIN {<VARIABLE>} {[SPAWN]} {[FADE]} {[LEGEND]}
will draw digital rain.
[JOINTED|TOP|LEFT|BOTTOM|RIGHT] SIDE
will draw one or more sides of a box.
[GRID] TABLE {[LIST1]} {[LIST2]}
will draw a table.
[HUGE] TILE {[TEXT1]} {[TEXT2]}
will draw a tile
All draw types take an optional text argument as long as a valid
square with enough space has been defined. Text is automatically
word wrapped.
Example: #draw Blue box 1 1 3 20 {Hello world!}
Related: buffer, echo, grep and showme.
ECHO
Command: #echo {format} {argument1} {argument2} {etc}
Echo command displays text on the screen with formatting options. See
the help file for the format command for more information.
The echo command does not trigger actions.
As with the #show command you can split the {format} argument up into
two braced arguments, in which case the 2nd argument is the row number.
Example: #echo {The current date is %t.} {%Y-%m-%d %H:%M:%S}
#echo {[%38s][%-38s]} {Hello World} {Hello World}
#echo {{this is %s on the top row} {-1}} {printed}
Related: buffer, format, grep and showme.
ELSE
Command: #else {commands}
The else statement should follow an #IF or #ELSEIF statement and is
only called if the proceeding #IF or #ELSEIF is false.
Example: #if {1d2 == 1} {smile};#else {grin}
Related: case, default, elseif, if, switch and regexp.
ELSEIF
Command: #elseif {conditional} {commands}
The elseif statement should follow an #IF or #ELSEIF statement and is
only called when the statement is true and the proceeding #IF and
#ELSEIF statements are false.
Example: #if {1d3 == 1} {smirk};#elseif {1d2 == 1} {snicker}
Related: case, default, else, if, switch and regexp.
END
Command: #end {<message>}
Terminates tintin and return to unix. On most systems, ctrl-c has
the same result.
The message is optional and is printed before tintin exits. When
using #end {\} tintin will terminate silently.
Related: zap ESCAPE CODES
You may use the escape character \ for various special characters.
\a beep the terminal.
\c send a control character, \ca for ctrl-a.
\e start an escape sequence.
\n send a line feed.
\r send a carriage return.
\t send a horizontal tab.
\x print an 8 bit character using hexadecimal, \xFF for example.
\x7B send the '{' character.
\x7D send the '}' character.
\u print a 16 bit unicode character, \uFFFD for example.
\U print a 21 bit unicode character, \U02AF21 for example.
\v send a vertical tab
Ending a line with \ will stop tintin from appending a line feed.
To escape arguments in an alias or action use %%0 %%1 %%2 etc.
Related: characters, colors, coordinates, mathematics and pcre.
EVENT
Command: #event {event type}
Events allow you to create triggers for predetermined client events.
Use #event without an argument to see a list of possible events with
a brief description. Use #event %* to see the current list of defined
events. Use #info {events} {on} to see events get thrown.
To enable mouse events use #config mouse_tracking on, to see mouse
events use #config mouse_tracking info.
Some events can be prefixed with CATCH to interrupt default behavior.
Some events can be prefixed with GAG to gag default messages.
CATCH <EVENT>
CHAT MESSAGE %0 default %1 plain
CLASS ACTIVATED %0 class name
CLASS DEACTIVATED %0 class name
DATE %1 month - %3 day %4 hour : %5 minute
DAY <DAY> %3 day of the month
DOUBLE-CLICKED <VAR> %0 row %1 col %2 -row %3 -col %4 word %5 line
END OF PATH
GAG <EVENT>
HOUR %4 hour
IAC <VAR> <VAR>
IAC SB GMCP <MODULE> %0 data %1 raw data
IAC SB MSSP %0 variable %1 value
IAC SB MSDP %0 variable %1 value %2 plain value
IAC SB MSDP <VAR> %0 variable %1 value %2 plain value
IAC SB NEW-ENVIRON %0 variable %1 value
IAC SB ZMP <VAR> %0 value
IAC SB <VAR> %0 raw text %1 raw data
KEYPRESS %0 character %1 unicode index
LONG-CLICKED <VAR> %0 row %1 col %2 -row %3 -col %4 word %5 line
MAP CREATE EXIT %0 vnum %1 exit name %2 exit cmd %3 exit vnum
MAP CREATE ROOM %0 vnum %1 name
MAP DELETE EXIT %0 vnum %1 exit name %2 exit cmd %3 exit vnum
MAP DELETE ROOM %0 vnum %1 name
MAP ENTER MAP %0 new vnum
MAP ENTER ROOM %0 new vnum %1 old vnum
MAP ENTER ROOM <VAR> %0 new vnum %1 old vnum
MAP EXIT MAP %0 old vnum
MAP EXIT ROOM %0 old vnum %1 new vnum
MAP EXIT ROOM <VAR> %0 old vnum %1 new vnum
MAP FOLLOW MAP %0 old vnum %1 new vnum %2 exit name
MAP MOUSE LOCATION %2 -row %3 -col %5 vnum %6 info
MAP REGION %0 row %1 col %2 -row %3 -col %5 vnum %6 info
MAP ROOM %0 row %1 col %2 -row %3 -col %5 vnum %6 info
MAP UPDATED VTMAP
MINUTE %5 minute
MONTH %1 month
MOVED <VAR> %0 row %1 col %2 -row %3 -col %4 word %5 line
PORT CONNECTION %0 name %1 ip %2 port
PORT DISCONNECTION %0 name %1 ip %2 port
PORT MESSAGE %0 data %1 plain data
PORT LOG MESSAGE %0 name %1 ip %2 port %3 data %4 plain data
PORT RECEIVED MESSAGE %0 name %1 ip %2 port %3 data %4 plain data
PRESSED <VAR> %0 row %1 col %2 -row %3 -col %4 word %5 line
PROGRAM START %0 startup arguments
PROGRAM TERMINATION %0 goodbye message
READ ERROR %0 filename %1 error message
RECEIVED INPUT %0 raw text
RECEIVED KEYPRESS %0 raw text %1 unicode index
RECEIVED LINE %0 raw text %1 plain text
RECEIVED OUTPUT %0 raw text
RECEIVED PROMPT %0 raw text %1 plain text
RELEASED <VAR> %0 row %1 col %2 -row %3 -col %4 word %5 line
SCAN CSV HEADER %0 all args %1 arg1 %2 arg2 .. %99 arg99
SCAN CSV LINE %0 all args %1 arg1 %2 arg3 .. %99 arg99
SCAN TSV HEADER %0 all args %1 arg1 %2 arg3 .. %99 arg99
SCAN TSV LINE %0 all args %1 arg1 %2 arg3 .. %99 arg99
SCREEN FOCUS %0 focus (0 or 1)
SCREEN LOCATION %0 rows %1 cols %2 height %3 width
SCREEN MOUSE LOCATION %0-3 screen row/col %4-7 cell row/col %8 loc
SCREEN RESIZE %0 rows %1 cols %2 height %3 width
SCREEN SPLIT %0 top row %1 top col %2 bot row %3 bot col
SCREEN UNSPLIT %0 top row %1 top col %2 bot row %3 bot col
SCROLLED <VAR> %0 row %1 col %2 -row %3 -col %4 word %5 line
SECOND %6 second
SEND OUTPUT %0 raw text %1 size
SENT OUTPUT %0 raw text %1 size
SESSION ACTIVATED %0 name
SESSION CONNECTED %0 name %1 host %2 ip %3 port
SESSION CREATED %0 name %1 host %2 ip %3 port
SESSION DEACTIVATED %0 name
SESSION DISCONNECTED %0 name %1 host %2 ip %3 port
SESSION TIMED OUT %0 name %1 host %2 ip %3 port
SHORT-CLICKED <VAR> %0 row %1 col %2 -row %3 -col %4 word %5 line
SWIPED <DIR>
%0 dir %1 button %2 row %3 col %4 -row %5 -col %6 row %7 col %8 -row
%9 -col %10 rows %11 cols
SYSTEM ERROR %0 name %1 system msg %2 error %3 error msg
TIME %4 hour : %5 minute : %6 second
TRIPLE-CLICKED <VAR> %0 row %1 col %2 -row %3 -col %4 word %5 line
UNKNOWN COMMAND %0 raw text
VARIABLE UPDATE <VAR> %0 name %1 new value
VARIABLE UPDATED <VAR> %0 name %1 new value
VT100 SCROLL REGION %0 top row %1 bot row %2 rows %3 cols %4 wrap
WEEK <DAY> %2 day of the week
WRITE ERROR %0 filename %1 error message
YEAR %0 year
To see all events trigger use #event info on. Since this can get
rather spammy it's possible to gag event info messages.
Example: #event {SESSION CONNECTED} {#read mychar.tin}
Comment: You can remove an event with the #unevent command.
Related: button, delay and ticker.
FOREACH
Command: #foreach {list} {variable} {commands}
For each item in the provided list the foreach statement will update
the given variable and execute the command part of the statement. List
elements must be separated by braces or semicolons.
Example: #foreach {bob;tim;kim} {name} {tell $name Hello}
Example: #foreach {{bob}{tim}{kim}} {name} {tell $name Hello}
Related: break, continue, list, loop, parse, repeat, return and while.
FORMAT
Command: #format {variable} {format} {argument1} {argument2} {etc}
Allows you to store a string into a variable in the exact same way
C's sprintf works with a few enhancements and limitations like a
maximum of 30 arguments.
If you use #format inside an alias or action you must escape %1s as
%+1s or %%1s or %\1s so the %1 isn't substituted by the trigger.
#format {test} {%+9s} {string} pad string with up to 9 spaces
#format {test} {%-9s} {string} post pad string with up to 9 spaces
#format {test} {%.8s} {string} copy at most 8 characters
#format {test} {%a} {number} print corresponding charset character
#format {test} {%c} {string} use a highlight color name
#format {test} {%d} {number} print a number with integer formatting
#format {test} {%f} {string} perform floating point math
#format {test} {%g} {number} perform thousand grouping on {number}
#format {test} {%h} {string} turn text into a header line
#format {test} {%l} {string} lowercase text
#format {test} {%m} {string} perform mathematical calculation
#format {test} {%n} {name} capitalize the first letter
#format {test} {%p} {string} strip leading and trailing spaces
#format {test} {%r} {string} reverse text, hiya = ayih
#format {test} {%s} {string} print given string
#format {test} {%t} {format} display time with strftime format
optional {{format}{time}} syntax
#format {test} {%u} {string} uppercase text
#format {list} {%w} {string} store word wrapped text in {list}
optional {{string}{width}} syntax
#format {test} {%x} {hex} print corresponding charset character
#format {test} {%A} {char} store corresponding character value
#format {test} {%C} {number} store number in chronological notation
#format {test} {%D} {hex} convert hex to decimal in {test}
#format {hash} {%H} {string} store a 64 bit string hash in {hash}
#format {test} {%L} {string} store the string length in {test}
#format {test} {%M} {number} convert number to metric in {test}
#format {test} {%S} {string} store the number of spelling errors
#format {time} {%T} {} store the epoch time in {time}
#format {time} {%U} {} store the micro epoch time in {time}
#format {test} {%X} {dec} convert dec to hexadecimal in {test}
#format {test} {%%} a literal % character
Comment: See #help TIME for help on the %t argument.
Related: cat, echo, function, local, math, replace, script, time and variable.
FUNCTION
Command: #function {name} {operation}
Functions allow you to execute a script within a line of text, and
replace the function call with the line of text generated by the
function.
Be aware that each function should set the $result variable at the
end of the function, or call #return with the given result.
To use a function use the @ character before the function name.
The function arguments should be placed between braces behind the
function name with argument separated by semicolons.
The function itself can use the provided arguments which are stored
in %1 to %9, with %0 holding all arguments.
Example: #function {rnd} {#math {result} {1 d (%2 - %1 + 1) + %1 - 1}}
#show A random number between 100 and 200: @rnd{100;200}
Example: #function gettime {#format result %t %H:%M}
#show The current time is @gettime{}
Comment: You can remove a function with the #unfunction command.
Related: format, local, math, replace, script and variable.
GAG
Command: #gag {string}
Removes any line that contains the string.
Comment: See '#help action', for more information about triggers.
There are a system messages that can be gagged using gag events.
Comment: You can remove a gag with the #ungag command.
Related: action, highlight, prompt and substitute.
GREETING
####################################################################
##
# T I N T I N + + 2.02.03b #
##
# Code by Peter Unold, Bill Reis, and Igor van den Hoven #
##
####################################################################
GREP
Command: #grep [page] {search string}
This command allows you to search for matching lines in your scroll
back buffer. The amount of matches shown equals your screen size. If
you want to search back further use the optional page number. You can
use wildcards for better search results. Be aware the search string
is case sensitive, which can be disabled by using %i.
By default grep searches from the end of the scrollback buffer to the
beginning, this can be reversed by using a negative page number.
Example: #grep Bubba tells you
This will show all occasions where bubba tells you something.
Related: buffer, echo and showme.
HELP
Command: #help {subject}
Without an argument #help will list all available help subjects.
Using #help %* will display all help entries.
Related: commands, debug, ignore, info, message and statements.
HIGHLIGHT
Command: #highlight {string} {color names} {priority}
The highlight command is used to allow you to highlight strings of text.
Available color options are:
reset - resets the color state to default
light - turns the color light in 16 color mode.
dark - turns the color dark in 16 color mode.
underscore - underscores the text.
blink - makes the text blink.
reverse - reverse foreground and background color.
b - makes next color the background color.
Available color names are:
<F06B> - azure <F08F> - Azure
<F00B> - blue <F00F> - Blue
<F0BB> - cyan <F0FF> - Cyan
<F000> - ebony <F666> - Ebony
<F0B0> - green <F0F0> - Green
<F0B6> - jade <F0F8> - Jade
<F6B0> - lime <F8F0> - Lime
<FB0B> - magenta <FF0F> - Magenta
<FB60> - orange <FF80> - Orange
<FB06> - pink <FF08> - Pink
<FB00> - red <FF00> - Red
<F888> - silver <FDDD> - Silver
<F860> - tan <FDB0> - Tan
<F60B> - violet <F80F> - Violet
<FBBB> - white <FFFF> - White
<FBB0> - yellow <FFF0> - Yellow
The %1-99 variables can be used as 'wildcards' that will match with any
text. They are useful for highlighting a complete line. The %0 variable
should never be used in highlights.
You may start the string to highlight with a ^ to only highlight text
if it begins the line.
Besides color names also <abc> color codes can be used.
Example: #high {Valgar} {reverse blink}
Prints every occurrence of 'Valgar' in blinking reverse video.
Example: #high {^You %1} {bold cyan}
Boldfaces any line that starts with 'You' in cyan.
Example: #high {Bubba} {red underscore b green}
Highlights the name Bubba as red underscored text on green background.
Comment: See '#help action', for more information about triggers.
Comment: See '#help substitute', for more advanced color substitution.
Comment: This command only works with ANSI/VT100 terminals or emulators.
Comment: You can remove a highlight with the #unhighlight command.
Related: action, gag, prompt and substitute.
HISTORY
Command: #history {delete} Delete the last command.
#history {insert} {command} Insert a command.
#history {list} Display the entire command history.
#history {read} {filename} Read a command history from file.
#history {write} {filename} Write a command history to file.
Without an argument all available options are shown.
By default all commands are saved to the history list and the history
list is saved between sessions in the ~/.tintin/history.txt file.
You can set the character to repeat a command in the history with the
#config {REPEAT CHAR} {<character>} configuration option, by default
this is set to the exclamation mark.
You can use ! by itself to repeat the last command, or !<text> to
repeat the last command starting with the given text.
You can use #config {REPEAT ENTER} {ON} to repeat the last command
when you press enter on an empty line.
You can press ctrl-r to enter an interactive regex enabled history
search mode, or by issuing #cursor {history search}.
TinTin++ tries to bind the arrow up and down keys to scroll through
the history list by default. You can bind these with a macro yourself
using #cursor {history next} and #cursor {history prev}. Many #cursor
commands only work properly when bound with a macro.
Related: alias, cursor, keypad, macro, speedwalk and tab.
IF
Command: #if {conditional} {commands if true} {commands if false}
The 'if' command is one of the most powerful commands added since
TINTIN III. It works similar to an 'if' statement in other languages,
and is strictly based on the way C handles its conditional statements.
When an 'if' command is encountered, the conditional statement is
evaluated, and if TRUE (any non-zero result) the commands are executed.
The 'if' statement is only evaluated if it is read, so you must nest
the 'if' statement inside another statement (most likely an 'action'
command). The conditional is evaluated exactly the same as in the
'math' command only instead of storing the result, the result is used
to determine whether to execute the commands.
Example: #action {%0 gives you %1 gold coins.} {#if {%1>5000} {thank %0}}
If someone gives you more than 5000 coins, thank them.
Comment: See '#help math', for more information.
Related: case, default, else, elseif, switch and regexp.
IGNORE
Command: #ignore {listname} {on|off}
Toggles a list on or off. With no arguments it shows your current
settings, as well as the list names that you can ignore.
If you for example set ACTIONS to OFF actions will no longer trigger.
Not every list can be ignored.
Related: class, debug, info, kill and message.
INDEX
INDEX
On this page you'll find an introduction to using TinTin++. Additional
information can be found in the individual help sections.
Starting and Ending
The syntax for starting TinTin++ is: ./tt++ [command file]
Read more about the command file in the files section below. Remember
one thing though. All actions, aliases, substitutions, etc, defined
when starting up TinTin++ are inherited by all sessions.
If you want to exit TinTin++ type '#end' or press ctrl-d on an empty
line.
For the WinTin++ users, if you want to paste text use shift-insert,
text is automatically copied upon selection. This is typical Linux
behavior, but it can take some getting used to.
Basic features
I'll start by explaining some of the very basic and important features:
All TinTin++ commands starts with a '#'.
Example: #help -- #help is a client command, and isn't send to the server.
All TinTin++ commands can be abbreviated when typed.
#he -- Typing #he is the same as typing #help though it's suggested to
use at least 3 letter abbreviations just in case another command is
added that starts with 'he'.
All commands can be separated with a ';'.
n;l green;s;say Dan Dare is back! -- do these 4 commands
There are 3 ways ';'s can be overruled.
\say Hello ;) -- Lines starting with a '\' aren't parsed by TinTin++.
say Hello \;) -- The escape character can escape 1 letter.
#config verbatim on -- Everything is send as is except '#' commands.
Connecting to a server
Command: #session {session name} {server address} {port}
Example: #session someone tintin.sourceforge.net 4321
You can have more than one session, in which case you can switch
between sessions typing #<session name>.
You can get a list of all sessions by typing: #session. The current
active session is marked with (active). Snooped sessions with
(snooped). MCCP sessions (compression) with (mccp 2) and (mccp 3).
Split
Command: #split
The split command will create a separated input and output area.
Using the #prompt command you can capture the prompt and place it on
the split line. To get rid of the split interface you can use #unsplit
which will restore the terminal settings to default.
Alias
Command: #alias {name} {commands}
The syntax of the #alias command is almost like alias in csh.
Use this command to define aliases. The variables %0, %1.. %9 contain
the arguments to the aliased command as follows:
the %0 variable contains ALL the arguments.
the %1 variable contains the 1st argument
....
the %9 variable contains the 9th argument
Example: #alias greet say Greetings, most honorable %1
If there are no variables on the right-side of the alias definition,
any arguments following the aliases-command will be appended to the
command string.
Example: #alias ff cast 'fireball' -- 'ff bob' equals: cast 'fireball' bob
If you want an alias to execute more commands, you must use braces.
Example: #alias ws {wake;stand}
To delete an alias use the #unalias command.
WARNING! TinTin++ doesn't baby sit, and hence does not check for
recursive aliases! You can avoid recursion by escaping the entire
line.
Example: #alias put \put %1 in %2
Or by using the send command.
Example: #send put %1 in %2
Action
Command: #action {action-text} {commands}
Use this command to define an action to take place when a particular
text appears on your screen. There are 99 variables you can use as
wildcards in the action-text.
These variables are %1, %2, %3 .... %9, %10, %11 ... %97, %98, %99.
Example: #action {You are hungry} {get bread bag;eat bread}Example: #action {%1 has arrived.} shake %1 -- shake hands with people arriving.
Example: #action {%1 tells you '%2'}
{tell bob %1 told me '%2'} -- forward tells.
Example: #action {tells you} #bell -- beep on tell.
You can have TinTin++ ignore actions if you type '#ignore actions on'.
You can see what commands TinTin++ executes when an action triggers
by typing '#debug actions on'.
You can remove actions with the #unaction command.
Highlight
Command: #highlight {text} {color}
This command works a bit like #action. The purpose of this command is
to substitute text from the server with color you provide. This command
is a simplified version of the #substitute command.
Example: #high {Snowy} {light yellow}Example: #high {%*Snowy%*} {light yellow}
Use #unhigh to delete highlights.
Speedwalk
If you type a command consisting ONLY of letters and numbers n, e, s,
w, u, d - then this command can be interpreted as a serie of movement
commands.
Example: ssw2n -- go south, south, west, north, north
If you have problems with typing some commands that actually ONLY
consists of these letters, then type them in CAPS. For example when
checking the NEWS or when asked to enter NEW as your name.
You must enable speedwalking with: #config speedwalk on/off.
Ticker
Command: #ticker {name} {commands} {seconds}
The name can be whatever you want it to be, and is only required for
the unticker command. The commands will be executed every x amount of
seconds, which is specified in the interval part.
Example: #tick {tick} {#delay 50 #show 10 SECONDS TO TICK!;#show TICK!!!} {60}
This creates a ticker with the name {tick} which will print TICK!!!,
as well as print a warning when the next tick will occure.
You can remove tickers with #untick
Command files
When you order TinTin++ to read a command file, it parses all the text
in the file. You can use command files to keep aliases/actions in,
login to a server (name, password etc..) and basically all kinds of
commands.
You can make the command files with either a text editor (suggested),
or use the #write command to write out a file.
Commands for files:
#read filename -- read and execute the file.
#write filename -- write all actions/aliases/substitutes/etc known for
the current session to a file.
Repeating Commands
You can repeat a command, the syntax is: #number command
Example: #5 cackle -- if you just killed bob the wizard.
Example: #10 {buy bread;put bread bag} -- repeat these 2 commands 10 times.
Example: #100 ooc w00t w00t!!!!! -- nochannel yourself.
History
TinTin++ has a limited subset of the csh history features.
! -- repeat the last command
!cast -- repeat the last command starting with cast
ctrl-r -- enter the reverse history search mode.
Map commands
TinTin++ has a powerful highly configurable automapper. Whenever
you type n/ne/e/se/s/sw/w/nw/n/u/d tt++ tries to keep track of your
movement.
Commands for map:
#map create -- create a map.
#map goto 1 -- go to the first room in the map, created by default.
#map map -- display the map.
#map undo -- undo your last map alteration.
#map write <filename> -- save the map to file.
#map read <filename> -- load a map from file.
There are many other map options and it's beyond the scope of this
help section to explain everything there is to know, but I'll give
a set of commands that will get most people started.
#map create
#split 12 1
#map flag unicode on
#map flag vt on
#map goto 1
These commands will create a 12 row vt100 split section at the top of
your screen where a map drawn using unicode characters is displayed.
Example: #action {There is no exit in that direction.} {#map undo}
The map will be automatically created as you move around.
Help
Command: #help {subject}
The help command is your friend and contains the same helpfiles
inside TinTin++ as are available on the website. If you type #help
without an argument you will see the various available help subjects
which try to explain the TinTin++ commands and features in greater
detail.
Enjoy INFO
Command: #info {listname} {LIST|ON|OFF|SAVE}
Without an argument info displays the settings of every tintin list.
By providing the name of a list and the LIST option it shows all
triggers/variables associated with that list. With the SAVE option
This data is written to the info variable.
#info cpu will show information about tintin's cpu usage.
#info mccp will show information about data compression.
#info stack will show the low level debugging stack.
#info session will show some session information.
#info system will show some system information.
#info unicode will show information on the provided character.
Related: class, debug, ignore, kill and message.
KEYPAD
When TinTin++ starts up it sends \e= to the terminal to enable the terminal's
application keypad mode, which can be disabled using #show {\e>}
Configuration A Configuration B Configuration C
╭─────┬─────┬─────┬─────╮ ╭─────┬─────┬─────┬─────╮ ╭─────┬─────┬─────┬─────╮
│num │/ │* │- │ │num │/ │* │- │ │Num │nkp/ │nkp* │nkp- │
├─────┼─────┼─────┼─────┤ ├─────┼─────┼─────┼─────┤ ├─────┼─────┼─────┼─────┤
│7 │8 │9 │+ │ │Home │Up │PgUp │+ │ │nkp7 │nkp8 │nkp9 │nkp+ │
├─────┼─────┼─────┤ │ ├─────┼─────┼─────┤ │ ├─────┼─────┼─────┤ │
│4 │5 │6 │ │ │Left │Cntr │Right│ │ │nkp4 │nkp5 │nkp6 │ │
├─────┼─────┼─────┼─────┤ ├─────┼─────┼─────┼─────┤ ├─────┼─────┼─────┼─────┤
│1 │2 │3 │Enter│ │End │Down │PgDn │Enter│ │nkp1 │nkp2 │nkp3 │nkpEn│
├─────┴─────┼─────┤ │ ├─────┴─────┼─────┤ │ ├─────┴─────┼─────┤ │
│0 │. │ │ │Ins │Del │ │ │nkp0 │nkp. │ │
╰───────────┴─────┴─────╯ ╰───────────┴─────┴─────╯ ╰───────────┴─────┴─────╯
With keypad mode disabled numlock on will give you configuration A, and numlock
off will give you configuration B. With keypad mode enabled you'll get
configuration C.
Terminals that support keypad mode
Linux Console, PuTTY, Eterm, aterm.
Terminals that do not support keypad mode
RXVT on Cygwin, Windows Console, Gnome Terminal, Konsole.
Peculiar Terminals
RXVT requires turning off numlock to enable configuration C.
Xterm may require disabling Alt/NumLock Modifiers (num-lock) in the ctrl-left
click menu. Or edit ~/.Xresources and add XTerm*VT100.numLock:false
Mac OS X Terminal requires enabling 'strict vt100 keypad behavior' in
Terminal -> Window Settings -> Emulation.
Related: colors, coordinates, escape, mathematics and pcre.
KILL
Command: #kill {list} {pattern}
Without an argument, the kill command clears all lists. Useful if
you don't want to exit tintin to reload your command files.
With one argument a specific list can be cleared.
With two arguments the triggers in the chosen list that match the
given pattern will be removed.
Example: #kill alias %*test*
Related: class, debug, ignore, info and message.
LINE
Command: #line {option} {argument}#line background <argument>
Prevent new session activation.
#line capture <variable> <argument.
Argument is executed and output stored in <variable>.
#line convert <argument>
Argument is executed with escaped meta characters.
#line debug <argument>
Argument is executed in debug mode.
#line gag
Gag the next line.
#line ignore {argument}
Argument is executed without any triggers being checked.
#line local {argument}
Argument is executed with all newly and indirectly
created variables being local.
#line log <filename> [text]
Log the next line to file unless the [text] argument is
provided.
#line logmode <option> <argument>
Argument is executed using the provided logmode, available
modes are: html, plain, and raw.
#line multishot <number> <argument>
Argument is executed in multishot mode, all triggers created
will only fire the given number of times.
#line oneshot <argument>
Argument is executed in oneshot mode, all triggers created will
only fire once.
#line quiet <argument>
Argument is executed with suppression of most system messages.
#line strip <argument>
Argument is executed with all color codes stripped.
#line substitute <options> <argument>
Argument is executed using the provided substitutions, available
options are: arguments, colors, escapes, functions, secure, and
variables.
#line verbatim <argument>
Argument is executed verbatim, prohibiting variable and function
substitutions.
#line verbose <argument>
Argument is executed with most system messages enabled.
When using #line log and logging in html format use \c< \c> \c& \c" to
log a literal < > & and ".
Related: class and config.
LIST
Command: #list {variable} {option} {argument}
#list {var} {add} {item} Add {item} to the list
#list {var} {clear} Empty the given list
#list {var} {collapse} Turn list into a variable
#list {var} {create} {item} Create a list using {items}
#list {var} {delete} {index} {number} Delete the item at {index},
the {number} is optional.
#list {var} {explode} Turn list into a character list
#list {var} {insert} {index} {string} Insert {string} at given index
#list {var} {find} {string} {variable} Return the found index
#list {var} {get} {index} {variable} Copy an item to {variable}
#list {var} {order} {string} Insert item in numerical order
#list {var} {shuffle} Shuffle the list
#list {var} {set} {index} {string} Change the item at {index}
#list {var} {simplify} {variable} Copy simple list to {variable}
#list {var} {size} {variable} Copy list size to {variable}
#list {var} {sort} {string} Insert item in alphabetic order
#list {var} {tokenize} {string} Create a character list
The index should be between 1 and the list's length. You can also give
a negative value, in which case -1 equals the last item in the list, -2
the second last, etc.
When inserting an item a positive index will prepend the item at the
given index, while a negative index will append the item.
The add and create options allow using multiple items, as well
as semicolon separated items.
A length of 0 is returned for an empty or non existant list.
You can directly access elements in a list variable using $var[1],
$var[2], $var[-1], etc.
Related: break, continue, foreach, loop, parse, repeat, return and while.
LISTS
There are several different types of lists in tintin which behave in a
fairly universal manner. To properly explain lists it's easiest to
explain the most basic variable type first before discussing more
complex types.
- Basic variable: The standard key = value variable.
- Simple list: A string that contains semicolon delimited fields.
{a;b;c}. Can be saved as a variable.
- Brace list: A string in which fields are delimited with braces.
{a}{b}{c}. Brace lists cannot be stored as a variable because tables
use braces as well, they must be stored as a simple list instead.
- Table: Think of this as variables nested within another variable. Or
as variables contained within another variable.
- List: A table that uses integers for its indexes. Also known as an
array. The #list command is a utility command for using tables as
arrays.
Simple Variables
Example:
#variable {simple} {Hello World!}
#show $simple
To see if the 'simple' variable exists you can use &simple which will
display 0 if the variable does not exist, or the variable's index if
it exists.
If you have multiple variables they are sorted alphabetically and
numerically. While it's not all that relevant for simple variables,
the first variable has index 1, the second variable index 2, and so
on.
Variable names need to start with a letter and only exist of letters,
numbers, and underscores. If you need to use a non standard variable
name this is possible using braces.
Example: #variable {:)} {Happy Happy!};#show ${:)}
Variables can be accessed using their index. While primarily useful
for tables it is possible to do this for simple variables. Use +1 for
the first variable, +2 for the second variable, etc. Use -1 for the
last variable, -2 for the second last variable, etc.
Example: #show The first variable is: ${+1}
Removing Variables
To remove a variable, use #unvariable or #unvar (every command can be
abbreviated). It's possible to remove multiple variables at once
using #unvar {var 1} {var 2} {etc}
Variables are unique to each session, so if you have multiple
sessions, removing a variable from one session won't remove it from
other sessions.
If you remove a table variable, all variables contained within that
table variable are removed as well.
Simple Lists
A simple list is a string that contains semicolon delimited fields.
Commands can be entered as simple lists, for example:
#show {a};#show {b} will execute a single line as two commands.
Several commands take a simple list as their input, these are:
#foreach, #line substitute, #path load, #list create, and #highlight.
Brace Lists
A brace list is a string in which fields are delimited with braces.
Most commands take a brace list for their arguments, for example:
#session {x} {mud.com} {1234} {mud.tin}. The session command takes
4 arguments, the 4th argument (command file) is optional.
Commands that take a simple list as their input will also accept a
brace list, keep in mind you'll have to embed the brace list in an
extra set of braces, for example: #path load {{n}{s}{w}{w}}, which is
identical to: #path load {n;s;w;w}.
Brace lists cannot be stored as variables because TinTin++ will
confuse them with tables. You can convert a brace list to a table
variable using: #list {bracelist} {create} {{a}{b}{c}} this will look
internally as: {{1}{a}{2}{b}{3}{c}}. You can then convert this table
to a simple list using: #list {bracelist} {simplify} {simplelist}
which will store {a;b;c} in the $simplelist variable.
Braces cannot easily be escaped in TinTin++. Using \{ or \} will not
work. The reason for this is due to several factors, but primarily
backward compatibility. To escape braces you must define them using
hexadecimal notation using \x7B and \x7D. See #help escape for a list
of escape options, and the help file will also remind you of how to
escape braces.
Tables
Tables are key/value pairs stored within a variable. Tables are also
known as associative arrays, dictionaries, maps, nested variables,
structures, and probably a couple of other names. There are several
ways to create and access tables.
Example: #variable {friendlist} {{bob}{bob@mail.com} {bubba}{sunset@gmail.com}}
This will create a friendlist with two entries, the key is the name of
the friend, the value is the email address of the friend. You can see
the email address of bob using: #show {$friendlist[bob]}. You can
also define this table as following:
Example:
#variable {friendlist[bob]} {bob@mail.com}
#variable {friendlist[bubba]} {sunset@gmail.com}
This would create the exact same table as the single line declaration
used previously. To see the first key in the table use:
*friendlist[+1], to see the first value in the table use:
$friendlist[+1]. To see the size of the table use &friendlist[]. To
print a bracelist of all friends use *friendlist[%*], to print a
bracelist of all friends whose name starts with the letter 'a' you
would use: *friendlist[a%*]. Similarly to see the number of friends
you have whose name ends with the letter 'b' you would use:
&friendlist[%*b].
See #help regexp for a brief overview of regular expression options.
While TinTin++ supports PCRE (perl-compatible regular expressions), it
embeds them within its own regular expression syntax that is simpler
and less invasive, while still allowing the full power of PCRE for
those who need it.
Example: #unvariable {friendlist[bubba]}
This would remove {bubba} from the friendlist. To remove the entire
friendlist you would use: #unvariable {friendlist}.
Example: #variable {friendlist} {{bob} {{email}{bob@ma.il} {phone}{123456789}}}
There is no limit to the number of nests, simply add more braces. To
see Bob's email in this example you would use:
#show {$friendlist[bob][email]}.
Lists
Tables are sorted alphabetically with the exception of numbers which
are sorted numerically. If you want to determine the sorting order
yourself you can use use the #list command which helps you to use
tables as arrays.
Example: #action {%1 chats %2} {#list chats add {%0}}
Each time a chat is received it's added to the end of the 'chats' list
variable. If you type #variable chats this might look like:
#VARIABLE {chats}
{
{1} {Bubba chats Hi}
{2} {Bob chats Hi bub}
{3} {Bubba chats Bye}
{4} {Bob chats bub bye}
}
Parsing
There are various ways to parse lists and tables, using either #loop,
#foreach, #while, or #<number>.
#loop takes two numeric arguments, incrementing or decrementing the
first number until it matches the second number. The value of the loop
counter is stored in the provided variable.
#foreach takes either a simple list or a brace list as its first
argument. Foreach will go through each item in the list and store the
value in the provided variable.
#while will perform an if check on the first argument, if the result
is true it will execute the commands in the second argument. Then it
performs an if check on the first argument again. It will continue to
repeat until the if check returns 0 or the loop is interrupted with a
control flow command. It takes special care to avoid infinite loops.
#<number> will execute the provided argument 'number' times. For
example: #4 {#show beep! \a}
Here are some examples.
Example: #list friends create {bob;bubba;zorro}
Internally this looks like {{1}{bob}{2}{bubba}{3}{zorro}} and the
list can be parsed in various ways.
Example: #foreach {$friends[%*]} {name} {#show $name}
Example: #foreach {*friends[%*]} {i} {#show $friends[$i]}
Example: #loop {1} {&friends[]} {i} {#show $friends[+$i]}
Example: #math i 1;#while {&friends[+$i]} {#show $friends[+$i];
#math i $i + 1}
Example: #math i 1;#&friends[] {#show $friends[+$i];#math i $i + 1}
Each of the five examples above performs the same task; printing the
three names in the friends list.
If you want to get a better look at what goes on behind the scenes
while executing scripts you can use '#debug all on'. To stop seeing
debug information use '#debug all off'.
Optimization
TinTin++ tables are exceptionally fast while they remain under 100
items. Once a table grows beyond 10000 items there can be performance
issues when inserting and removing items in the beginning or middle of
the table.
The plan is to eventually implement an indexable and flexible data
structure for large tables.
If you load a large table from file it's important to make sure it's
sorted, when using #write to save a table it's automatically sorted.
If you notice performance issues on large tables it's relatively easy
to create a hash table.
Example:
#alias {sethash}
{
#format hash %H %1;
#math hash1 $hash % 100;
#math hash2 $hash / 100 % 100;
#var hashtable[$hash1][$hash2][%1] %2
}
#function {gethash}
{
#format hash %H %1;
#math hash1 $hash % 100;
#math hash2 $hash / 100 % 100;
#return $hashtable[$hash1][$hash2][%1]
}
#alias {test}
{
sethash bli hey;
sethash bla hi;
sethash blo hello;
#show The value of bla is: @gethash{bla}
}
The above script will rapidly store and retrieve over 1 million items.
Looping through a hash table is relatively easy as well.
Example:
#alias {showhash}
{
#foreach {*hashtable[%*]} {hash1}
{
#foreach {*hashtable[$hash1][%*]} {hash2}
{
#echo {%-20s = %s}
{hashtable[$hash1][$hash2]}
{$hashtable[$hash1][$hash2]}
}
}
}
Related: break, continue, foreach, loop, parse, repeat, return and while.
LOCAL
Command: #local {variable name} {text to fill variable}
The local command sets a local variable. Unlike a regular variable
a local variable will only stay in memory for the duration of the
event that created it. They are accessed in the same way as a
regular variable.
Commands that store information to a variable will use a local variable
if it exists.
Avoid setting the result variable as local in a function.
Example: #alias {swap} {#local x %0;#replace x {e} {u};#show $x}
Related: format, function, math, replace, script and variable.
LOG
Command: #log {append|overwrite|off} {[filename]}
Logs session output to a file, you can set the data type to either
plain, raw, or html with the config command.
Related: read, scan, textin and write.
LOOP
Command: #loop {<start>} {<finish>} {<variable>} {commands}
Like a for statement, loop will loop from start to finish incrementing
or decrementing by 1 each time through. The value of the loop counter
is stored in the provided variable, which you can use in the commands.
Example: #loop 1 3 loop {get all $loop\.corpse}
This equals 'get all 1.corpse;get all 2.corpse;get all 3.corpse'.
The . needs to be escaped so it's not treated as part of the variable.
Example: #loop 3 1 cnt {drop $cnt\.key}
This equals 'drop 3.key;drop 2.key;drop 1.key'.
Related: break, continue, foreach, list, parse, repeat, return and while.
MACRO
Command: #macro {key sequence} {commands}
Macros allow you to make tintin respond to function keys.
The key sequence send to the terminal when pressing a function key
differs for every OS and terminal. To find out what sequence is send
you can enable the CONVERT META config option.
Another option is pressing ctrl-v, which will enable CONVERT META for
the next key pressed.
If you only want a key sequence to trigger at the start of an input
line prefix the key sequence with ^.
Example: #macro {(press ctrl-v)(press F1)} {#show \e[2J;#buffer lock}
Clear the screen and lock the window when you press F1, useful when the
boss is near.
Example: #macro {\eOM} {#cursor enter}
Makes the keypad's enter key work as an enter in keypad mode.
Example: #macro {^nn} {n}
Makes pressing n twice on an empty line execute north.
Comment: Not all terminals properly initialize the keypad key sequences.
If this is the case you can still use the keypad, but instead of the
arrow keys use ctrl b, f, p, and n.
Comment: You can remove a macro with the #unmacro command.
Related: alias, cursor, history, keypad, speedwalk and tab.
MAP
Command: #map
The map command is the backbone of the auto mapping feature.
#map at <exit|vnum> <command>
Execute the command at the given exit or vnum.
#map center <x> <y> <z>
Sets displaying center of the map viewer, default is 0 0 0.
#map color <field> [value]
Sets the map color for the given color field.
#map create <size>
Creates a new map and room 1. The default size is 50000 rooms.
#map destroy {area|world} <name>
Deletes the map or given area.
#map delete <exit|vnum>
Deletes the room for the given exit or vnum.
#map dig <exit|vnum> [new|<vnum>]
Creates an exit for the given exit name. If no valid exit name
is given or no existing room is found a new room is created.
Useful for portal links and other alternative forms of
transportation. If the 'new' argument is provided all existing
rooms are ignored and a new room is created. If a room vnum is
given as the second argument an exit will be created leading
to the given room vnum. If the room vnum doesn't exist a new
room is created.
#map entrance <exit> [option] [arg]
Set the entrance data for the given exit. You must specify a
valid two-way exit for this to work.
#map exit <exit> <option> <arg>
Set the exit data. Useful with a closed door where you can
set the exit command: '#map exit e command {open east;e}'.
Use #map exit <exit> for a list of available options.
#map exitflag <exit> <AVOID|BLOCK|HIDE|INVIS> [on|off]
Set exit flags. See #map roomflag for more info.
#map explore <exit>
Explores the given exit until a dead end or an
intersection is found. The route is stored in #path and can
subsequently be used with #walk. Useful for long roads.
#map find <name> <exits> <desc> <area> <note> <terrain> <flag>
searches for the given room name. If found the shortest path
from your current location to the destination is calculated.
The route is stored in #path and can subsequently be used with
the various #path commands. If <exits> is provided all exits
must be matched, if <roomdesc>, <roomarea> or <roomnote> or
<roomterrain> or <roomflag> is provided these are matched as
well against the room to be found.
These options are also available to the at, delete, goto
link, list and run commands.
#map flag asciigraphics
Takes up more space but draws a more detailed
map that displays the ne se sw nw exits and room symbols.
#map flag asciivnums
Display room vnums if asciigraphics is enabled.
#map flag nofollow
When you enter movement commands the map will no longer
automatically follow along. Useful for MSDP and GMCP
automapping scripts.
#map flag static
Will make the map static so new rooms are no longer
created when walking into an unmapped direction. Useful when
you're done mapping and regularly bump into walls accidentally
creating a new room. #map dig etc will still work.
#map flag vtgraphics
Enables vt line drawing on some terminals
#map flag vtmap
Will enable the vtmap which is shown in the top split
screen if you have one. You can create a 16 rows high top
screen by using '#split 16 1'.
#map get <option> <variable> [vnum]
Store a map value into a variable, if no vnum is given the
current room is used. Use 'all' as the option to store all
values as a table.
#map get roomexits <variable>
Store all room exits into variable.
#map global <room vnum>
Set the vnum of a room that contains global
exits, for example an exit named 'recall' that leads to the
recall location. The room can contain multiple exits, in case
there are multiple commands that are similar to recall.
#map goto <room vnum> [dig]
Takes you to the given room vnum, with the
dig argument a new room will be created if none exists.
#map goto <name> <exits> <desc> <area> <note> <terrain>
Takes you to the given room name, if you provide exits those
must match.
#map info
Gives information about the map and room you are in.
#map insert <direction> [roomflag]
Insert a room in the given direction. Most useful for inserting
void rooms.
#map jump <x> <y> <z>
Jump to the given coordinate, which is relative
to your current room.
#map landmark <name> <vnum> [description] [size]
Creates an alias to target the provided room vnum. The
description is optional and should be brief. The size
determines from how many rooms away the landmark can be
seen.
#map leave
Makes you leave the map. Useful when entering a maze. You
can return to your last known room using #map return.
#map legend <legend> [symbols|reset]
#map legend <legend> <index> [symbol]
There are several legends and sub-legends available for
drawing maps to suit personal preference and character sets.
Use #map legend all to see the legend as currently defined.
Use #map legend <legend> <reset> to set the default legend.
Use #map legend <legend> <character list> to create a custom
legend. Custom legends are automatically saved and loaded by
using #map read and #map write.
#map link <direction> <room name> [both]
Links two rooms. If the both
argument and a valid direction is given the link is two ways.
#map list <name> <exits> <desc> <area> <note> <terrain>
Lists all matching rooms and their distance. The following
search keywords are supported.
{roomarea} <arg> will list rooms with matching area name.
{roomdesc} <arg> will list rooms with matching room desc.
{roomexits} <arg> will list rooms with identical room exits.
{roomflag} <arg> will list rooms with matching room flags.
{roomid} <arg> will list rooms with identical id name.
{roomname} <arg> will list rooms with matching room name.
{roomnote} <arg> will list rooms with matching room note.
{roomterrain} <arg> will list rooms with matching room terrain.
{variable} <arg> will save the output to given variable.
#map map <rows> <cols> <append|overwrite|list|variable> <name>
Display a drawing of the map of the given height and width.
All arguments are optional. If {rows} or {cols} are set to {}
or {0} they will use the scrolling window size as the default.
If {rows} or {cols} are a negative number this number is
subtracted from the scrolling window size.
#map map <rows> <cols> draw <square>
Display a drawing of the map of the given height and width.
The square argument exists of 4 numbers formulating the top
left corner and bottom right corner of a square.
If you use {append|overwrite} the map is written to the specified
file name which must be given as the 4th argument.
If you use {list|variable} the map is saved to the specified
variable name.
#map move <direction>
This does the same as an actual movement
command, updating your location on the map and creating new
rooms. Useful when you are following someone and want the map
to follow. You will need to create actions using '#map move',
for this to work.
#map offset <row> <col> <row> <col>
Define the offset of the vtmap as a square. Without an argument
it defaults to the entire top split region.
#map read <filename>
Will load the given map file.
#map resize <size>
Resize the map, setting the maximum number of rooms.
#map return
Returns you to your last known room after leaving the map
or loading a map.
#map roomflag <flags> <get|on|off>
#map roomflag avoid
When set, '#map find' will avoid a route leading
through that room. Useful for locked doors, etc.
#map roomflag block
When set the automapper will prevent movement into or through
the room. Useful for death traps.
#map roomflag hide
When set, '#map' will not display the map beyond
this room. When mapping overlapping areas or areas that aren't
build consistently you need this flag as well to stop
auto-linking, unless you use void rooms.
#map roomflag invis
When set the room will be colored with the INVIS color.
#map roomflag leave
When entering a room with this flag, you will
automatically leave the map. Useful when set at the entrance
of an unmappable maze.
#map roomflag noglobal
This marks a room as not allowing global
transportation, like norecall rooms that block recall.
#map roomflag void
When set the room becomes a spacing room that can
be used to connect otherwise overlapping areas. A void room
should only have two exits. When entering a void room you are
moved to the connecting room until you enter a non void room.
#map roomflag static
When set the room will no longer be autolinked
when walking around. Useful for mapping mazes.
#map run <room name> [delay]
Calculates the shortest path to the destination and walks you
there. The delay is optional and requires using braces. Besides
the room name a list of exits can be provided for more precise
matching.
#map set <option> <value> [vnum]
Set a map value for your current room, or given room if a room
vnum is provided.
#map sync <filename>
Similar to #map read except the current map won't be unloaded
or overwritten.
#map terrain <name> <symbol> [flag]
Set the terrain symbol and flag.
#map terrain <name> <symbol> [DENSE|SPARSE|SCANT]
Determine symbol density, omit for the default.
#map terrain <name> <symbol> [NARROW|WIDE|VAST]
Determine symbol spread range, omit for the default.
#map terrain <name> <symbol> [FADEIN|FADEOUT]
Determine symbol spread density, omit for the default.
#map terrain <name> <symbol> [DOUBLE]
You're using two characters for the symbol.
#map travel <direction> <delay>
Follows the direction until a dead end or an intersection is
found. Use braces around the direction if you use the delay,
which will add the given delay between movements.
Use #path stop to stop a delayed run.
#map undo
Will undo your last move. If this created a room or a link
they will be deleted, otherwise you'll simply move back a
room. Useful if you walked into a non existant direction.
#map uninsert <direction>
Exact opposite of the insert command.
#map unlandmark <name>
Removes a landmark.
#map unlink <direction> [both]
Will remove the exit, this isn't two way so you can have the
properly display no exit rooms and mazes.
If you use the both argument the exit is removed two-ways.
#map unterrain <name>
Removes a terrain.
#map update [now]
Sets the vtmap to update within the next 0.1 seconds, or
instantly with the now argument.
#map vnum <low> [high]
Change the room vnum to the given number, if a range is
provided the first available room in that range is selected.
#map write <filename> [force]
Will save the map, if you want to save a map to a .tin file
you must provide the {force} argument.
Related: path and pathdir.
MAPPING
TinTin++ has a powerful automapper that uses a room system similar to
Diku MUDs which means that odd map layouts and weird exit
configurations aren't a problem. The mapper provides tools to improve
the visual map display. For basic path tracking see #help PATH.
#map create [size]
This command creates the initial map. The size is 50,000 by default
and can be changed at any time with the #map resize command. If you
play a MUD that uses MSDP or GMCP to provide room numbers you'll have
to increase it to the highest reported room number. Increasing the
size of the map doesn't decrease performance.
#map goto <location>
When you create the map you are not automatically inside the map. By
default room number (vnum) 1 is created, so you can go to it using
#map goto 1. Once you are inside the map new rooms are automatically
created as you move around. Movement commands are defined with the
pathdir command. By default n, ne, e, se, s, sw, w, nw, u, d are
defined.
#map map <rows> <cols> <append|overwrite|list|variable> <name>
To see the map you can use #map map. It's annoying to have to
constantly type #map map however. Instead it's possible to use #split
to display a vt100 map. To do so execute:
#split 16 1
#map flag vtmap on
The first command sets the top split lines to 16 and the bottom split
line to 1. If you want a smaller or larger map display you can use a
different value than 16.
If you don't need to display diagonal exits and prefer a more compact
look you can use #map flag AsciiGraphics off. This will enable the
standard display which uses UTF-8 box drawing characters, results may
vary depending on the font used.
If your terminal supports UTF-8 you can also give #Map flag unicode on
a try.
If you want to display the map in a different location of the screen
use something like:
#split 0 1 0 -80
#map offset 1 81 -4 -1
This will display the map on the right side of the screen, if the
width of the screen is wide enough.
#map undo
If you accidentally walk into the wall on your MUD the mapper will
still create a new room. You can easily fix this mistake by using
#map undo. If you want to move around on the map without moving around
on the MUD you can use: #map move {direction}. To delete a room
manually you can use: #map delete {direction}. To create a room
manually you can use: #map dig {direction}.
#map write <filename>
You can save your map using #map write, to load a map you can use
#map read <filename>.
#map set <option> <value>
You can set the room name using #map set roomname <name>. You either
have to do this manually or create triggers to set the room name
automatically. Once the room name is set you can use #map goto with
the room name to visit it. If there are two rooms with the same name
#map goto will go to the most nearby room. If you want to always go
to the same room you should memorize the room number. You can further
narrow down the matches by providing additional arguments, for example:
#map goto {dark alley} {roomexits} {n;e} {roomarea} {Haddock Ville}
You can set the room weight using #map set roomweight {value}. The
weight by default is set to 1.0 and it represents the difficulty of
traversing the room. If you have a lake as an alternative route, and
traversing water rooms is 4 times slower than regular rooms, then you
could set the weight of the lake rooms to 4.0. If the lake is 3 rooms
wide the total weight is 12. If walking around the lake has a weight
less than 12 the mapper will go around the lake, if the weight is
greater than 12 the mapper will take a route through the lake.
You can set the room symbol using #map set roomsymbol {value}. The
symbol should be one, two, or three characters, which can be
colorized. You can for example mark shops with an 'S' and colorize the
'S' depending on what type of shop it is.
#map run <location> <delay>
The run command will have tintin find the shortest path to the given
location and execute the movement commands to get there. You can
provide a delay in seconds with floating point precision, for example:
#map run {dark alley} {0.5}
#map insert {direction} {flag}
The insert command is useful for adding spacer rooms called void rooms.
Often rooms overlap, and by adding void rooms you can stretch out
exits. For example: #map insert north void. You cannot enter void rooms
once they've been created, so you'll have to use #map info in an
adjacent room to find the room vnum, then use #map goto {vnum} to
visit.
It's also possible to align rooms using void rooms. This is easily
done using #map insert north void.
Related: map, path and pathdir.
MATH
Command: #math {variable} {expression}
Performs math operations and stores the result in a variable. The math
follows a C-like precedence, as follows, with the top of the list
having the highest priority.
Operators Priority Function
------------------------------------------------
! 0 logical not
~ 0 bitwise not
* 1 integer multiply
** 1 integer power
/ 1 integer divide
// 1 integer sqrt // 2 or cbrt // 3
% 1 integer modulo
d 1 integer random dice roll
+ 2 integer addition
- 2 integer subtraction
<< 3 bitwise shift
>> 3 bitwise shift
.. 3 bitwise ellipsis
> 4 logical greater than
>= 4 logical greater than or equal
< 4 logical less than
<= 4 logical less than or equal
== 5 logical equal (can use regex)
=== 5 logical equal (never regex)
!= 5 logical not equal (can use regex)
!== 5 logical not equal (never regex)
& 6 bitwise and
^ 7 bitwise xor
| 8 bitwise or
&& 9 logical and
^^ 10 logical xor
|| 11 logical or
True is any non-zero number, and False is zero. Parentheses () have
highest precedence, so inside the () is always evaluated first.
Strings must be enclosed in { } and use regex with == and !=,
in the case of <= and >= the alphabetic order is compared.
The #if and #switch commands use #math. Several commands accepting
integer input allow math operations as well.
Floating point precision is added by using the decimal . operator.
Time in seconds is calculated using [day]:[hour]:<minute>:<second>.
Example: #math {heals} {$mana / 40}
Assuming there is a variable $mana, divides its value by 40 and stores
the result in $heals.
Example: #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.
Example: #action {%0 tells %1}
{#if {{%0} == {Bubba} && $afk} {reply I'm away, my friend.}}
When you are away from keyboard, it will only reply to your friend.
Related: cat, format, function, local, mathematics, replace, script and variable.
MATHEMATICS
Number operations
Operators Priority Function
------------------------------------------------
! 0 logical not
~ 0 bitwise not
* 1 integer multiply
** 1 integer power
/ 1 integer divide
// 1 integer sqrt // 2 or cbrt // 3
% 1 integer modulo
d 1 integer random dice roll
+ 2 integer addition
- 2 integer subtraction
<< 3 bitwise shift
>> 3 bitwise shift
> 4 logical greater than
>= 4 logical greater than or equal
< 4 logical less than
<= 4 logical less than or equal
== 5 logical equal
!= 5 logical not equal
& 6 bitwise and
^ 7 bitwise xor
| 8 bitwise or
&& 9 logical and
^^ 10 logical xor
|| 11 logical or
Operator priority can be ignored by using parentheses, for example (1 + 1) * 2
equals 4, while 1 + 1 * 2 equals 3.
String operations
Operators Priority Function
------------------------------------------------
> 4 alphabetical greater than
>= 4 alphabetical greater than or equal
< 4 alphabetical less than
<= 4 alphabetical less than or equal
== 5 alphabetical equal (can use regex)
!= 5 alphabetical not equal (can use regex)
Strings must be encased in double quotes or braces. The > >= < <= operators
perform basic string comparisons. The == != operators perform regular
expressions, with the argument on the left being the string, and the argument
on the right being the regex. For example {bla} == {%*a} would evaluate as 1.
Related: math MESSAGE
Command: #message {listname} {on|off}
This will show the message status of all your lists if typed without an
argument. If you set for example VARIABLES to OFF you will no longer be
spammed when correctly using the #VARIABLE and #UNVARIABLE commands.
Related: class, debug, ignore, info and kill.
METRIC SYSTEM
Name Symbol Factor
--------------------------------------------------
Mega M 1 000 000
Kilo K 1 000
milli m 0.001
micro u 0.000 001
Related: echo, format and math.
MSDP
MSDP (Mud Server Data Protocol) is part of the #port functionality.
See #help event for additional documentation as all MSDP events are
available as regular events.
Available MSDP events can be queried using the MSDP protocol
as described in the specification.
https://tintin.sourceforge.io/protocols/msdp
Related: event and port.
MSLP
MSLP (Mud Server Link Protocol) is supported by TinTin++. See #help
event for additional documentation as all MSLP events are available
as regular events.
Available MSLP sequences can be generated using the MSLP protocol
as described in the specification.
https://tintin.mudhalla.net/protocols/mslp
Related: event and port.
NOP
Command: #nop {whatever}
Short for 'no operation', and is ignored by the client. It is useful
for commenting in your coms file, any text after the nop and before a
semicolon or end of line is ignored. You shouldn't put braces { } in it
though, unless you close them properly.
Comment: By using braces you can comment out multiple lines of code in a script
file.
For commenting out an entire trigger and especially large sections of
triggers you would want to use /* text */
Example: #nop This is the start of my script file.
Related: read PARSE
Command: #parse {string} {variable} {commands}
Like the loop statement, parse will loop from start to finish through
the given string. The value of the current character is stored in the
provided variable.
Example: #parse {hello world} {char} {#show $char}
Related: break, continue, foreach, list, loop, repeat, return and while.
PATH
Command: #path {option} {argument}
create Will clear the path and start path mapping.
delete Will delete the last move of the path.
describe Describe the path and current position.
destroy Will clear the path and stop path mapping.
get Will get either the length or position.
goto Go the the start, end, or given position index.
insert Add the given argument to the path.
load Load the given variable as the new path.
map Display the map and the current position.
move Move the position forward or backward. If a number is given
the position is changed by the given number of steps.
run Execute the current path, with an optional floating point
delay in seconds as the second argument.
save Save the path to a variable. You must specify whether you
want to save the path 'forward' or 'backward'.
swap Switch the forward and backward path.
unzip Load the given speedwalk as the new path.
walk Take one step forward or backward.
zip Turn the path into a speedwalk.
Example: #path ins {unlock n;open n} {unlock s;open s}
Related: map and pathdir.
PATHDIR
Command: #pathdir {dir} {reversed dir} {coord}
By default tintin sets the most commonly used movement commands
meaning you generally don't really have to bother with pathdirs.
Pathdirs are used by the #path and #map commands.
The first argument is a direction, the second argument is the reversed
direction. The reverse direction of north is south, etc.
The third argument is a spatial coordinate which is a power of two.
'n' is 1, 'e' is 2, 's' is 4, 'w' is '8', 'u' is 16, 'd' is 32. The
exception is for compound directions, whose value should be the sum
of the values of each cardinal direction it is composed of. For
example, 'nw' is the sum of 'n' and 'w' which is 1 + 8, so 'nw'
needs to be given the value of 9. This value is required for the
#map functionality to work properly.
Example: #pathdir {ue} {dw} {18}
#pathdir {dw} {ue} {40}
Comment: You can remove a pathdir with the #unpathdir command.
Related: map and path.
PCRE
A regular expression, regex or regexp is a sequence of characters that
defines a search pattern. Since the 1980s, different syntaxes for
writing regular expressions exist, the two most widely used ones being
the POSIX syntax and the similar but more advanced Perl standard.
TinTin++ supports the Perl standard known as PCRE (Perl Compatible
Regular Expressions).
Regular expressions are an integral part of TinTin++, but keep in mind
that tintin doesn't allow you to use regular expressions directly,
instead it uses a simpler intermediate syntax that still allows more
complex expressions when needed.
Commands that utilize regular expressions are: action, alias, elseif,
gag, grep, highlight, if, kill, local, math, prompt, regexp, replace,
substitute, switch, variable and while. Several other commands use
regular expressions in minor ways. Fortunately the basics are very
easy to learn.
TinTin++ Regular Expression
The following support is available for regular expressions.
^ match start of line.
$ match of end of line.
\ escape one character.
%1-%99 match of any text, stored in the corresponding index.
%0 should be avoided in the regex, contains all matched text.
{ } embed a perl compatible regular expression, matches are stored.
%!{ } embed a perc compatible regular expression, matches are not stored.
[ ] . + | ( ) ? * are treated as normal text unless used within braces. Keep in
mind that { } is replaced with ( ) automatically unless %!{ } is used.
TinTin++ Description POSIX
%d Match zero to any number of digits ([0-9]*?)
%D Match zero to any number of non-digits ([^0-9]*?)
%i Matches become case insensitive (?i)
%I Matches become case sensitive (default) (?-i)
%s Match zero to any number of spaces ([\r\n\t ]*?)
%w Match zero to any number of word characters ([A-Za-z0-9_]*?)
%W Match zero to any number of non-word characters ([^A-Za-z0-9_]*?)
%? Match zero or one character (.??)
%. Match one character (.)
%+ Match one to any number of characters (.+?)
%* Match zero to any number of characters (.*?)
Variables
If you use %1 in an action to perform a match the matched string is
stored in the %1 variable which can be used in the action body.
Example: %1 says 'Tickle me'} {tickle %1}
If you use %2 the match is stored in %2, etc. If you use an unnumbered
match like %* or %S the match is stored at the last used index
incremented by one.
Example: %3 says '%*'} {#if {"%4" == "Tickle me"} {tickle %3}}
The maximum variable index is 99. If you begin an action with %* the
match is stored in %1. You should never use %0 in the trigger part of
an action, when used in the body of an action %0 contains all the parts
of the string that were matched.
To prevent a match from being stored use %!*, %!w, etc.
Perl Compatible Regular Expressions
You can embed a PCRE (Perl Compatible Regular Expression) using curley
braces { }, these braces are replaced with parentheses ( ) unless you
use %!{ }.
Or
You can separate alternatives within a PCRE using the | character.
Example: #act {%* raises {his|her|its} eyebrows.} {say 42..}
Brackets
You can group alternatives and ranges within a PCRE using brackets.
Example: #act {%* says 'Who is number {[1-9]}} {say $number[%2] is number %2}
The example only triggers if someone provides a number between 1 and
9. Any other character will cause the action to not trigger.
Example: #act {%* says 'Set password to {[^0-9]*}$} {say The password must
contain at least one number, not for security reasons, but just to
annoy you.} {4}
When the ^ character is used within brackets it creates an inverse
search, [^0-9] matches every character except for a number between 0
and 9.
Quantification
A quantifier placed after a match specifies how often the match is
allowed to occur.
? repeat zero or one time.
* repeat zero or multiple times.
+ repeat once or multiple times.
{n} repeat exactly n times, n must be a number.
{n,} repeat at least n times, n must be a number.
{n,o} repeat between n and o times, n and o must be a number.
Example: #act {%* says 'Who is number {[1-9][0-9]{0,2}} {Say $number[%2] is
number %2}
The example only triggers if someone provides a number between 1 and
999.
Parantheses
TinTin Regular Expressions automatically add parenthesis, for example
%* translates to (.*?) in PCRE unless the %* is found at the start or
end of the line, in which cases it translates to (.*). Paranthesis in
PCRE causes a change in execution priority similar to mathematical
expressions, but parentheses also causes the match to be stored to a
variable.
When nesting multiple sets of parentheses each nest is assigned its
numerical variable in order of appearance.
Example: #act {%* chats '{Mu(ha)+}'} {chat %2ha!}
If someone chats Muha you will chat Muhaha! If someone chats Muhaha
you will chat Muhahaha!
Lazy vs Greedy
By default regex matches are greedy, meaning {.*} will capture as much
text as possible.
Example: #regex {bli bla blo} {^{.*} {.*}$} {#show Arg1=(&1) Arg2=(&2)}
This will display: Arg1=(bli bla) Arg2=(blo)
By appending a ? behind a regex it becomes lazy, meaning {.*?} will
capture as little text as possible.
Example: #regex {bli bla blo} {^{.*?} {.*?}$} {#show Arg1=(&1) Arg2=(&2)}
This will display: Arg1=(bli) Arg2=(bla blo).
Escape Codes
PCRE support the following escape codes.
PCRE Description POSIX
\A Match start of string ^
\b Match word boundaries (^|\r|\n|\t| |$)
\B Match non-word boundaries [^\r\n\t ]
\c Insert control character \c
\d Match digits [0-9]
\D Match non-digits [^0-9]
\e Insert escape character \e
\f Insert form feed character \f
\n Insert line feed character \n
\r Insert carriage return character \r
\s Match spaces [\r\n\t ]
\S Match non-spaces [^\r\n\t ]
\t Insert tab character \t
\w Match letters, numbers, and underscores [A-Za-z0-9_]
\W Match non-letters, numbers, and underscores [^A-Za-z0-9_]
\x Insert hex character \x
\Z Match end of string $
\s matches one space, \s+ matches one or multiple spaces.
Color triggers
To make matching easier text triggers (Actions, Gags, Highlights,
Prompts, and Substitutes) have their color codes stripped. If you
want to create a color trigger you must start the triggers with a ~
(tilde). To make escape codes visible use #config {convert meta} on.
Example: #action {~\e[1;37m%1} {#var roomname %1}
If the room name is the only line on the server in bright white
white color trigger will save the roomname.
This covers the basics. PCRE has more options, most of which are
somewhat obscure, so you'll have to read a PCRE manual for additional
information.
Related: map and path.
PORT
Command: #port {option} {argument}#port {init} {name} {port} {file}
Initilize a port session.
#port {call} {address} {port}
Connect to a remote socket.
#port {color} {color names}
Set the default color of port messages.
#port {dnd}
Do Not Disturb. Decline new connections
#port {group} {name} {group}
Assign a socket group.
#port {ignore} {name}
Ignore a socket
#port {info}
Display information about the port session.
#port {name} {name}
Change socket name.
#port {prefix} {text}
Set prefix before each message.
#port {send} {name|all} {text}
Send data to socket
#port {uninitialize}
Uninitialize the port session.
#port {who}
Show all connections
#port {zap} {name}
Close a connection
The port command is very similar to chat except that it creates a
new session dedicated to receiving socket connections at the given
port number without built-in support for a communication protocol.
You can init with 0 as the port number to create a dummy session.
Related: all, chat, run, session, sessionname, snoop, ssl and zap.
PROMPT
Command: #prompt {text} {new text} {row #} {col #}
Prompt is a feature for split window mode, which will capture a line
received from the server and display it on the status bar of your
split screen terminal. You would define <text> and <new text> the
same way as with a substitution.
The row number is optional and useful if you use a non standard split
mode. A positive row number draws #row lines from the top while a
negative number draws #row lines from the bottom. Without an argument
#prompt will write to the default split line, which is at row -2.
The col number is optional and can be used to set the column index.
A positive col number draws the given number of columns from the left,
while a negative col number draws from the right. If you leave the
column argument empty tintin will clear the row before printing at
the start of the row.
The #show command takes a row and col argument as well so it's also
possible to place text on your split lines using #show.
Comment: See #help split for more information on split mode.
Comment: See #help substitute for more information on text
substitutions.
Comment: You can remove a prompt with the #unprompt command.
Related: action, gag, highlight and substitute.
READ
Command: #read {filename}
Reads a commands file into memory. The coms file is merged in with
the currently loaded commands. Duplicate commands are overwritten.
If you uses braces, { and } you can use several lines for 1 commands.
This however means you must always match every { with a } for the read
command to work.
You can comment out triggers using /* text */
Related: log, scan, textin and write.
REGEXP
Command: #regexp {string} {expression} {true} {false}
Compares the string to the given regular expression.
Variables are stored in &1 to &99 with &0 holding the matched substring.
^ force match of start of line.
$ force match of end of line.
\ escape one character.
%1-%99 lazy match of any text, available at %1-%99.
%0 should be avoided in triggers, and if left alone lists all matches.
{ } embed a raw regular expression, matches are stored to %1-%99.
%!{ } embed a raw regular expression, matches are not stored.
[ ] . + | ( ) ? * are treated as normal text unlessed used within
braces. Keep in mind that { } is replaced with ( ) automatically
unless %!{ } is used.
Of the following the (lazy) match is available at %1-%99 + 1
%a match zero to any number of characters except newlines.
%A match zero to any number of newlines.
%d match zero to any number of digits.
%D match zero to any number of non digits.
%p match zero to any number of printable characters.
%P match zero to any number of non printable characters.
%s match zero to any number of spaces.
%S match zero to any number of non spaces.
%u match zero to any number of unicode characters.
%U match zero to any number of non unicode characters.
%w match zero to any number of word characters.
%W match zero to any number of non word characters.
If you want to match 1 digit use %+1d, if you want to match between 3
and 5 spaces use %+3..5s, if you want to match between 0 and 1 word
characters use %+0..1w
%+ match one to any number of characters.
%? match zero or one character.
%. match one character.
%* match zero to any number of characters.
%i matching becomes case insensitive.
%I matching becomes case sensitive (default).
The match is automatically stored to a value between %1 and %99
starting at %1 and incrementing by 1 for every regex. If you use
%15 as a regular expression, the next unnumbered regular expression
would be %16. To prevent a match from being stored use %!*, %!w, etc.
Example: #regexp {bli bla blo} {bli {.*} blo} {#show &1}
Related: case, default, else, elseif, if and switch.
REPEAT
Command: #[number] {commands}
Sometimes you want to repeat the same command multiple times. This is the
easiest way to accomplish that.
Example: #10 {buy bread}
Related: break, continue, foreach, list, loop, parse, return and while.
REPLACE
Command: #replace {variable} {oldtext} {newtext}
Searches the variable text replacing each occurrence of 'oldtext' with
'newtext'.
Related: cat, format, function, local, math, script and variable.
RETURN
Command: #return {text}
This command can be used to break out of a command string being
executed.
If used inside a #function you can use #return with an argument to both
break out of the function and set the result variable.
Related: break, continue, foreach, list, loop, parse, repeat and while.
RUN
Command: #run {name} {shell command} {file}
The run command works much like the system command except that it
runs the command in a pseudo terminal. The run command also creates
a session that treats the given shell command as a server. This
allows you to run ssh, as well as any other shell application, with
full tintin scripting capabilities. If a file name is given the file
is loaded prior to execution.
Example: #run {somewhere} {ssh someone@somewhere.com}
Example: #run {something} {tail -f chats.log}
Related: all, port, session, sessionname, snoop, ssl and zap.
SCAN
Command: #scan {abort|csv|tsv|txt} {filename}
The scan command is a file loading utility.
#scan {abort}
This command must be called from with a SCAN event and will
abort the scan if one is in progress.
#scan {csv} <filename>
The scan csv command reads in a comma separated value file
without printing the content to the screen. Instead it triggers one
of two events.
The SCAN CSV HEADER event is triggered on the first line of the csv
file. The SCAN CSV LINE event is triggered on the second and each
subsequent line of the csv file. The %0 argument contains the entire
line, with %1 containing the first value, %2 the second value, etc,
all the way up to %99.
Values containing spaces must be surrounded with quotes, keep in mind
newlines within quotes are not supported. Use two quotes to print one
literal quote character.
#scan {tsv} <filename>
The scan tsv <filename> command reads in a tab separated value file
without printing the content to the screen. Instead it triggers the
SCAN TSV HEADER event for the first line and SCAN TSV LINE for all
subsequent lines.
#scan {file} <filename> {commands}
The scan file command reads the given files and executes the
commands argument. &0 contains the raw content of the file and
&1 contains the plain content. &2 contains the raw byte size of the
file and &3 the plain byte size. &5 contains the line count.
#scan {txt} <filename>
The scan txt <filename> command reads in a file and sends its content
to the screen as if it was send by a server. After using scan you can
use page-up and down to view the file.
This command is useful to convert ansi color files to html or viewing
raw log files.
Actions, highlights, and substitutions will trigger as normal, and it
is possible to create an action to execute #scan abort to prematurely
stop the scan.
Related: read and textin.
SCREEN
Command: #screen {option} {argument}
The screen command offers a variety of screen manipulation
commands and utilities.
#screen blur
Move the terminal to the back of the stack.
#screen clear [all|scroll region|square] <args>
Provide 4 arguments defining the top left and bottom right corner
when erasing a square.
#screen focus
Move the terminal to the front of the stack.
#screen fullscreen [on|off]
Toggles fullscreen mode when used without an argument.
#screen get <option> <var>
Get various screen options and save them to <var>. Use #screen
get without an argument to see all available options.
#screen info
Debugging information.
#screen input <square>
Set the input region
#screen load <both|label|title>
Reload the saved title, label, or both.
#screen minimize <on|off>
Minimize with on, restore with off.
#screen maximize [on|off]
Maximize with on, restore with off.
#screen move <height> <width>
Move the upper left corner of the terminal to pixel coordinate.
#screen raise <event>
This will raise several screen events with %1 and %2 arguments.
#screen refresh
Terminal dependant, may do nothing.
#screen rescale <height> <width>
Resize the screen to the given height and width in pixels.
#screen resize <rows> <cols>
Resize the screen to the given height and width in characters.
#screen save <both|label|title>
Save the title, label, or both.
#screen scroll <square>
Set the scrolling region, changes the split setting.
#screen set <both|label|title>
Set the title, label, or both. Only title works on Windows.
Related: bell SCREEN READER
Command: #config {SCREEN READER} {ON|OFF}
Screen reader mode is enabled by using #config screen on. The main
purpose of the screen reader mode is to report to servers that a
screen reader is being used by utilizing the MTTS standard. The MTTS
specification is available at:
http://tintin.sourceforge.net/protocols/mtts
With the screen reader mode enabled TinTin++ will try to remove visual
elements where possible.
Related: config SCRIPT
Command: #script {variable} {shell command}
The script command works much like the system command except that it
treats the generated echos as commands if no variable is provided.
This is useful for running php, perl, ruby, and python scripts. You
can run these scrips either from file or from within tintin if the
scripting language allows this.
If you provide a variable the output of the script is stored as a list.
Example: #script {ruby -e 'print "#show hello world"'}
Example: #script {python -c 'print "#show hello world"'}
Example: #script {php -r 'echo "#show hello world"'}
Example: #script {path} {pwd};#show The path is $path[1].
Related: format, function, local, math, replace and variable.
SEND
Command: #send {text}
Sends the text directly to the server, useful if you want to start
with an escape code.
Related: textin SESSION
Command: #session {name} {host} {port} {file}
Starts a telnet session with the given name, host, port, and optional
file name. The name can be anything you want, except the name of an
already existant session, a number, or the keywords '+', '-' and 'self'.
If a file name is given the file is only read if the session succesfully
connects.
Without an argument #session shows the currently defined sessions.
If you have more than one session, you can use the following commands:
#session {-} Switch to the previous session.
#session {+} Switch to the next session.
#session {<number>} Switch to the given session. Session 0 is the
startup session, +1 the first, +2 the second, and
-1 is the last session. Sessions are (currently)
sorted in order of creation.
#gts Switch to the startup session. The name gts stands
for global tintin session.
#ats Switch to the active session. The name ats stands
for active tintin session.
not necessarily the calling session.
#{name} Activates to the session with the given name.
#{name} {command}: Executes a command with the given session without
changing the active session.
@<name>{text}: Parse text in the given session, substituting the
variables and functions, and print the result in
the current active session.
The startup session is named 'gts' and can be used for relog scripts.
Do keep in mind that tickers do not work in the startup session.
Example: #event {SESSION DISCONNECTED} {#gts #delay 10 #ses %0 tintin.net 4321}
Related: all, port, run, sessionname, snoop, ssl and zap.
SESSIONNAME
Syntax: #[sessionname] {commands}
You can create multiple sessions with the #session command. By default only one
session is active, meaning commands you input are executed in the active
session. While all sessions receive output, only output sent to the active
session is displayed.
When you create a session with the #session command you must specify a session
name, the session name, prepended with a hashtag, can be used to activate the
session when used without an argument. If an argument is given it will be
executed by that session as a command, the session will not be activated.
Example: #ses one tintin.net 23;#ses two tintin.net 23;#one;#two grin
This will create two sessions, the session that was created last (two in this
case) will be automatically activated upon creation. Using #one, session one is
activated. Using #two grin, the grin social will be executed by session two,
session one will remain the active session.
Related: all, port, run, session, snoop, ssl and zap.
SHOWME
Command: #show {string} {row} {col}
Display the string to the terminal, do not send to the server. Useful
for status, warnings, etc. The {row} and col number are optional and
work the same way as the row number of the #prompt trigger.
Actions can be triggered by the show command. If you want to avoid
this from happening use: #line ignore #show {<string>}.
Example: #tick {TICK} {#delay 50 #show 10 SECONDS TO TICK!!!} {60}
Comment: The #prompt helpfile contains more information on using the
option {row} and {col} arguments.
Related: buffer, draw, echo and grep.
SNOOP
Command: #snoop {session name} {on|off}
If there are multiple sessions active, this command allows you to monitor
what is going on in the sessions that are not currently active. The
line of text from other sessions will be prefixed by the session's name.
You can toggle off snoop mode by executing #snoop a second time.
Related: all, port, run, session, sessionname, ssl and zap.
SPEEDWALK
Speedwalking allows you to enter multiple directions without using
semicolons. Directions should be prefixed with a number and will be
executed the given number of times.
You can enable speedwalking with #CONFIG {SPEEDWALK} {ON}.
Example: Without speedwalk, you have to type:
s;s;w;w;w;w;w;s;s;s;w;w;w;n;n;w
With speedwalk, you only have to type:
2s5w3s3w2n1w
Related: alias, cursor, history, keypad, macro and tab.
SPLIT
Command: #split {top bar} {bottom bar}
Command: #split {<square>}
This option requires for your terminal to support VT100 emulation.
#split allows the creation of a top status bar, a scrolling region, a
bottom status bar, and an input line.
--top status bar--------
scrolling region
--bottom status bar----------
input line
By default the bottom status bar is filled with dashes --- and
subsequently it is also known as the split line. The scrolling
region is also known as the main screen and this is where all
incoming text is displayed by default.
If you use #split without an argument it will set the height of the
top status bar to 0 lines and the bottom status bar to 1 line.
If you use #split with one argument it will set the height of the top
status bar to the given number of lines and the bottom status bar will
be set to 1 line.
If you use two arguments the first argument is the height of the top
status bar and the second argument the height of the bottom status bar.
The third and fourth argument are optional and tintin will interpret
four arguments as a square argument existing of two coordinates
defining the upper left corner and bottom right corner of the
scrolling region.
Example: #split 0 0
This will create a split screen with just a scrolling regino and an
input line. Great for the minimalist.
Comment: You can display text on the split line(s) with the #prompt and
#show {line} {row} commands.
Comment: You can remove split mode with the #unsplit command.
Related: echo, prompt and showme.
SSL
Command: #ssl {name} {host} {port} {file}
Starts a secure socket telnet session with the given name, host, port,
and optional file name.
Related: all, port, run, sessionname, snoop, ssl and zap.
STATEMENTS
TinTin++ knows the following statements.
#break
#case {value} {true}
#continue
#default {commands}
#else {commands}
#elseif {expression} {true}
#foreach {list} {variable} {commands}
#if {expression} {true}
#loop {min} {max} {variable} {commands}
#parse {string} {variable} {commands}
#return {value}
#switch {expression} {commands}
#while {expression} {commands}
Related: commands, help and info.
SUBSTITUTE
Command: #substitute {text} {new text} {priority}
Allows you to replace text from the server with the new text.
This is helpful for complex coloring and making things more readable.
The %1-%99 variables can be used to capture text and use it as part of
the new output, and the ^ char is valid to only check the beginning of
the line for the text specified.
If only one argument is given, all active substitutions that match the
strings are displayed. The '%*' char is valid in this instance. See
'#help regex', for advanced wildcard information.
If no argument is given, all subs are displayed.
Example: #sub {Zoe} {ZOE}
Any instance of Zoe will be replaced with ZOE.
Example: #sub {~\e[0;34m} {\e[1;34m}
Replace generic dark blue color codes with bright blue ones.
Example: #sub {%1massacres%2} {<018>%1<118>MASSACRES<018>%2}
Replaces all occurrences of 'massacres' with 'MASSACRES' in red.
Comment: See '#help action', for more information about triggers.
Comment: See '#help colors', for more information.
Comment: You can remove a substitution with the #unsubstitute command.
Related: action, gag, highlight and prompt.
SUSPEND
Command: #cursor suspend
Temporarily suspends tintin and returns you to your shell. To
return to tintin, type 'fg' at the shell prompt.
While suspended your tintin sessions will freeze. To keep a
suspended session running use the #detach command.
Related: end SWITCH
Command: #switch {conditional} {arguments}
The switch command works similar to the switch statement in other
languages. When the 'switch' command is encountered its body is parsed
and each 'case' command found will be compared to the conditional
argument of the switch and executed if there is a match.
When comparing strings the switch and case arguments must be enclosed
in quote characters.
If the 'default' command is found and no 'case' statement has been
matched the default command's argument is executed.
Example: #switch {1d4} {#case 1 cackle;#case 2 smile;#default giggle}
Related: statements SYSTEM
Command: #system {command}
Executes the command specified as a shell command.
Related: detach, script and run.
TAB
Command: #tab {word}
Adds a word to the tab completion list, alphabetically sorted.
If no tabs are defined tintin will use the scrollback buffer
for auto tab completion.
Comment: You can remove a tab with the #untab command.
Related: alias, cursor, history, keypad, macro and speedwalk.
TEXTIN
Command: #textin {filename} {delay}
Textin allows the user to read in a file, and send its contents
directly to the server. Useful for doing online creation, or message
writing.
The delay is in seconds and takes a floating point number which is
cumulatively applied to each outgoing line.
Related: scan and send.
TICKER
Command: #ticker {name} {commands} {interval in seconds}
Executes given command every # of seconds.
Comment: Tickers don't work in the startup session.
Comment: You can remove a ticker with the #unticker command.
Related: delay and event.
TIME
Command: #format {variable} {%t} {argument}
The %t format specifier of the #format command allows printing dates
using the strftime() format specifiers. By default the time stamp used
is the current time, if you want to print a past or future date use:
Command: #format {variable} {%t} {{argument} {{epoch time}}
The current epoch time value is obtained using #format {time} {%T}.
When using %t the argument should contain strftime format specifiers.
The output may differ depending on your locale.
%a Abbreviated name of the day of the week (mon ... sun).
%A Full name of the day of the week. (Monday ... Sunday)
%b Abbreviated name of the month (Jan ... Dec)
%B Full name of the month. (January ... December)
%C 2 digit numeric century. (19 ... 20)
%d 2 digit numeric day of the month (01 ... 31)
%H 2 digit numeric 24-hour clock hour. (00 ... 23)
%I 2 digit numeric 12-hour clock hour. (01 ... 12)
%j 3 digit numeric day of the year (001 ... 366)
%m 2 digit numeric month of the year (01 ... 12)
%M 2 digit numeric minute of the hour (00 ... 59)
%p Abbreviated 12 hour clock period (AM ... PM)
%P Abbreviated 12 hour clock period (am ... pm)
%S 2 digit numeric second of the minute (00 ...59
%u 1 digit numeric day of the week (1 ... 7)
%U 2 digit numeric Sunday week of the year (00 ... 53
%w 1 digit numeric day of the week (0 ... 6)
%W 2 digit numeric Monday week of the year (00 ... 53
%y 2 digit numeric year. (70 ... 38)
%Y 4 digit numeric year. (1970 ... 2038)
%z 5 digit timezone offset. (-1200 ... +1400)
%Z Abbreviated name of the time zone.
Related: echo, event and format.
VARIABLE
Command: #variable {variable name} {text to fill variable}
Variables differ from the %0-99 arguments in the fact that you can
specify a full word as a variable, and they stay in memory for the
full session unless they are changed. They can be saved in the
coms file, and can be set to different values if you have two or
more sessions running at the same time. Variables are global for
each session and can be accessed by adding a $ before the variable
name.
Example: #alias {target} {#var target %0}
#alias {x} {kick $target}
The name of a variable must exist of only letters, numbers and
underscores in order to be substituted. If you do not meet these
requirements do not panic, simply encapsulate the variable in braces:
Example: #variable {cool website} {http://tintin.sourceforge.net}
#chat I was on ${cool website} yesterday!.
Variables can be nested using brackets or dots:
Example: #var hp[self] 34;#var hp[target] 46
You can see the first nest of a variable using $variable[+1] and the
last nest using $variable[-1]. Using $variable[-2] will report the
second last variable, and so on. To show all indices use $variable[].
To show all values use $variable[%*] or a less generic regex.
Nested variables are also known as tables, table generally being used
to refer to several variables nested within one specific variable.
Example: #show {Targets starting with the letter A: $targets[A%*]
To see the internal index of a variable use &<variable name>. To see
the size of a table you would use: &targets[] or &targets[%*]. A non
existent nested variable will report itself as 0.
Example: #show {Number of targets starting with A: &targets[A%*]
In some scripts you need to know the name of a nested variable. This
is also known as the key, and you can get it using *variable. For
example *target[+1]. To get the first variable's name use *{+1}.
It's also possible to declare a table using brace notation. Using
#var hp[self] 34 is the equivalent of #var {hp} {{self}{34}}. This
also allows merging tables. #var hp[self] 34;#var hp[target] 46 is
the equivalent of #var {hp} {{self}{34} {target}{46}} as well as
#var {hp} {{self}{34}} {{target}{46}} or if you want to get creative
the equivalent of #var hp[self] 34;#var {hp} {$hp} {{target}{46}}.
Comment: You can remove a variable with the #unvariable command.
Related: cat, format, function, local, math, replace and script.
WHILE
Command: #while {conditional} {commands}
This command works similar to a 'while' statement in other languages.
When a 'while' command is encourated, the conditional is evaluated,
and if TRUE (any non-zero result) the commands are executed. The
'while' loop will be repeated indefinitely until the conditional is
FALSE or the #BREAK or #RETURN commands are found.
The 'while' statement is only evaluated if it is read, so you must
nest it inside a trigger, like an alias or action.
The conditional is evaluated exactly the same as in the 'math' command.
Example: #math cnt 0;#while {$cnt < 20} {#math cnt $cnt + 1;say $cnt}
Comment: See '#help math', for more information.
Related: statements WRITE
Command: #write {<filename>} {[FORCE]}
Writes all current actions, aliases, subs, highlights, and variables
to a command file, specified by filename.
By default you cannot write to .map files to prevent accidentally
overwriting a map file. Use the FORCE argument to ignore this
protection.
Related: log, read, scan and textin.
ZAP
Command: #zap {[session]}
Kill your current session. If there is no current session, it will
cause the program to terminate. If you provide an argument it'll zap
the given session instead.
Related: all, port, run, session, sessionname, snoop and ssl.
tt/docs/mslp_protocol.txt 0000664 0601750 0601001 00000003760 13653647361 015355 0 ustar eigenaar None To create the most basic link insert text between \e[4m and \e[24m. These are
the VT100 codes for underline on and underline off.
#showme {Example: \e[4mlink1\e[24m ... \e[4mlink2\e[24m}
------------------------------------------------------------------------------
If you want to create a link without the underline use \e[4;24m instead of
\e[4m.
#showme {Example: \e[4;24mlink3 (no underline)\e[24m}
------------------------------------------------------------------------------
Links when clicked generate a LINK event, which are visible if you use
#config mouse info. Example:
#event {SHORT-CLICKED LINK MOUSE BUTTON ONE} {#showme {click!}}
------------------------------------------------------------------------------
If you want to create a complex link use an OSC code.
\e]68;hello world\a\e[4mlink4\e[24m
The link part remains the same, \e[4mlink4\e[24m, but since it is prefixed
with the OSC code \e]68;hello world\a the %4 argument of the triggered LINK
event will contain hello world.
------------------------------------------------------------------------------
\e]68;\001test\002hello world\a\e[4mlink5\e[24m
The OSC code can contain MSDP. \001 indicates the start of a variable
name, and \002 indicates the start of a variable value. In tintin
this gets translated to {test}{hello world} which is available in the
%4 argument of the event.
------------------------------------------------------------------------------
\e]68;\001name6a\002value6a\001name6b\002value6b\a\e[4mlink6\e[24m};
In tintin this gets translated to {name6a}{value6a}{name6b}{value6b}
------------------------------------------------------------------------------
\e]68;0;command\a
This is the most basic link.
\e]68;0;
\e]68;1;
These three are identical and generate a standard link event.
------------------------------------------------------------------------------
\e]68;2;
In tintin the ;2; option is used for internal help files.
------------------------------------------------------------------------------
tt/docs/ssl.txt 0000664 0601750 0601001 00000010161 13537151322 013237 0 ustar eigenaar None SERVER CONFIGURATION
--------------------
No changes are made to tintin or script configuration. The plan is to tunnel
an SSL connection to your #port or #chat port.
One problem is that redirected connections will appear to originate from
localhost. Fortunately tintin can handle this if needed.
You'll need to install the 'stunnel' package or download it from the
www.stunnel.org website. There is a Windows version of stunnel with
essentially the same interface.
You'll also need the 'openssl' package.
If you do this on Ubuntu the package might install the command as stunnel4
while stunnel calls stunnel3. Be mindful of that.
Create a directory to store the certificates, and the stunnel config file.
Create a self-signed certificate using openssl. For more info see:
http://www.stunnel.org/faq/certs.html
Switch to the directory where you want to store the certs, and then run the
command to generate a self-signed cert:
openssl req -new -x509 -days 3650 -nodes -out stunnel.pem -keyout stunnel.pem
It will prompt you for some information. The only thing you really need to
change from default, is the Common Name entry, which you should specify the
full hostname of your server, for example: server.domain.com
Do not enter a passphrase for the cert, otherwise you will be prompted to
enter this passphrase every single time you start stunnel.
Run chmod 660 stunnel.pem
Stunnel will fail if the permissions are not correct on the file.
Create the config file for stunnel4, for example tinssl.conf, and use the
following contents, adjusting where necessary:
Code: [Select]
foreground = no
pid=/home/user/.tintin/ssl/tinssl.pid
[tinssl]
accept=4051
cert=/home/user/.tintin/ssl/stunnel.pem
key=/home/user/.tintin/ssl/stunnel.pem
client=no
connect=localhost:4050
The foreground option - change this to 'yes' to keep stunnel in the foreground
initially. Useful to see errors. Specify the pid to a writable path, or set it
to "pid=" for no pid file. If you don't know what a pid file is you can leave
it blank.
The segment headed by [tinssl] is the service entry. The name is arbitrary,
and there can be multiple entries if you want more tunnels. "accept=4051" is
the port for stunnel to listen for connections. "client=no" is software
default - this specifies a server connection, so stunnel must listen on 4051
for SSL connections. "connect=localhost:4050" This specifies where stunnel
will direct the incoming SSL connection. In this case, to tintin's default
chat port.
Now run: stunnel4 tinssl.conf
It should disappear into the background, or if you set foreground=yes, you
will see the basic log.
Run "ps -aux|grep stunnel" to verify that stunnel is running. There will
probably be around 4 processes running (For some odd reason). For
Windows, you should have an icon in the system tray.
With tintin you can now connect to the port using the #ssl command. To
connect to a chat port you'd have to run the connection through another
stunnel proxy. If there are problems check the logs and verify you opened
the port on your firewall, etc.
CLIENT CONFIGURATION
--------------------
If you want to use an SSL connection over #chat you can set up stunnel in
client mode to connect to your new SSL proxy. In this case we'll use
Windows, but it's virtually identical on any supported platform.
Install stunnel for Windows.
Edit the stunnel config from the convenient menu entry. Leave everything as
is, and add a service entry at the bottom of the file:
Code: [Select]
[tinssl]
accept = 12345
connect = server.domain.com:4051
client = yes
"accept=12345" is the LOCAL port for stunnel to listen on.
"connect=server.domain.com:4051" is the SSL server to connect to, in this
case, your newly configured stunnel on your host server.
"client=yes" This is important, stunnel will NOT work properly if you do not
set client=yes here.
Run stunnel, and you will get a new icon in your systray. You can right-click
it and 'View Log' to see what's going on, if you like. Run tintin and create
a chat connection to localhost, port 12345 (or whatever you configured).
You should be momentarily connected to the given ssl server.
Special thanks to Vilentus for the original documentation.
tt/docs/syntax.txt 0000664 0601750 0601001 00000026200 13656647042 014000 0 ustar eigenaar None CHARACTERS
----------
The following special characters are defined:
# The hashtag is the default character for starting a command and is
subsequently known as the command character or tintin character.
When loading a command file the command character is set to the
first character in the file. The character can also be redefined
using #config.
; The semi-colon is used as the command separator and can be used to
separate two commands. Multiple commands can be strung together as
well. Trailing semi-colons are ignored when reading a script file
as this is a common error.
{ } Curly brackets aka braces are used for seperating multi word command
arguments, nesting commands, and nesting variables. Braces cannot
easily be escaped and must always be used in pairs.
" " Quote characters are used for strings in the #math, #if, #switch,
and #case commands. It is however suggested to use an extra
set of braces { } to define strings.
! The exclamation sign is used to repeat commands, see #help history.
The character can be redefined using #config.
\ An input line starting with a backslash is send verbatim if you are
connected to a server. This character can be configured with
#config.
SUBSTITUTIONS
-------------
$&*@ All variable and function names must begin with an alphabetic
character, followed by any number of alphanumeric characters
and underscores.
$ The dollar sign is used to retrieve the value of a variable.
& The ampersand sign is used to retrieve the index of a variable.
* The astrix sign is used to retrieve the name of a variable.
@ The at sign followed by an alphanumeric string is used for functions.
[ ] Brackets are used for nested variables which function as an
associative array. Associative arrays are also known as tables and
maps. Regex can be used within brackets to match multiple variables.
&0- &99 The ampersand sign followed by a number is used for arguments in the
regex command.
%0- %99 The percent sign followed by a number is used for arguments by the
following triggers:
alias, action, button, delay, event, function, substitute, and tick.
<000> Three alphanumeric characters encapsulated by the less- and greater-
than signs are used for 4 and 8 bit color codes.
<0000> Either a B (background) or F (foreground) followed by three
hexadecimal characters encapsulated by < > signs are used for 12
bit color codes. Requires truecolor capable terminal.
<0000000> Either a B (background) or F (foreground) followed by six
hexadecimal characters encapsulated by < > signs are used for 24
bit color codes. Requires truecolor capable terminal.
More information is available at #help color.
\ The back slash is used to escape a character. All available options
are listed at #help escape. Escapes are typically escaped when text
leaves the client, by being send to a server, the shell, or being
displayed on the screen.
\t 08 horizontal tab character.
\n 10 line feed character.
\v 11 vertical tab character.
\r 13 carriage return character.
\e 27 escape character.
\c 6 bit control character, \ca for ctrl-a.
\x 8 bit character using 2 hexadecimal numbers.
\u 16 bit unicode character, \uFFFD for example.
All variables and functions can be escaped by doubling the sign,
like $$variable_name or @@function_name. To escape a variable
twice use $$$var_name. One escape is removed each time tintin
needs to substitute a variable or function.
All command arguments can be escaped by doubling the ampersand,
like &&1. One escape is removed each time tintin substitutes
command arguments.
All trigger arguments can be escaped by double the ampersand,
like %%1. One escape is removed each time tintin substitutes
trigger arguments.
COORDINATES
-----------
When the 0,0 coordinate is in the upper left corner TinTin++ uses
a y,x / rows,cols notation, starting at 1,1. Subsequently -1,-1
will indicate the bottom right corner.
When the 0,0 coordinate is in the bottom left corner tintin uses
a standard x,y notation.
SQUARES
-------
A square argument takes 4 coordinates. The first two coordinates
define the upper left corner, the last two coordinates define the
bottom right corner.
PANES
-----
A panes argument takes 4 size values, which are: top pane, bottom
pane, left pane, right pane. When a negative value is provided the
size is the maximum size, minus the value.
MATH
----
Operators Priority Function
------------------------------------------------
! 0 logical not
~ 0 bitwise not
* 1 integer multiply
** 1 integer power
/ 1 integer divide
// 1 integer sqrt // 2 or cbrt // 3
% 1 integer modulo
d 1 integer random dice roll
+ 2 integer addition
- 2 integer subtraction
<< 3 bitwise shift
>> 3 bitwise shift
> 4 logical greater than
>= 4 logical greater than or equal
< 4 logical less than
<= 4 logical less than or equal
== 5 logical equal (can use regex)
!= 5 logical not equal (can use regex)
=== 5 string equal
!== 5 string not equal
& 6 bitwise and
^ 7 bitwise xor
| 8 bitwise or
&& 9 logical and
^^ 10 logical xor
|| 11 logical or
: The colon can be used in #math to indicate a time value.
1:30 This means 1 minute and 30 seconds and equals 90 seconds.
2:1:30 This means 2 hours, 1 minute and 30 seconds.
6:2:1:30 This means 6 days, 2 hours, 1 minute and 30 seconds.
#math time 6:2:1:30 equals 525690
M,K,m,u These four metric suffixes are allowed for numbers.
{ } Braces can be used in #math to perform string operations.
{a} > {b} This checks if the string "a" is greater than "b".
, Commas in numbers are ignored, as well as spaces and tabs.
. Dots can be used in #math to perform floating point calculations.
The precision is set to the highest precision number used in the
calculation.
( ) Braces can be used in #math to prioritize a calculation.
STATEMENTS
----------
TT++ has the following commands which behave like statements.
#break
#case {value} {true}
#continue
#default {commands}
#else {commands}
#elseif {expression} {true}
#foreach {list} {variable} {commands}
#if {expression} {true}
#loop {min} {max} {variable} {commands}
#parse {string} {variable} {commands}
#return {value}
#switch {expression} {commands}
#while {expression} {commands}
REGEX
-----
^ force match of start of line.
$ force match of end of line.
\ escape one character.
%1-%99 lazy match of any text, available at %1-%99.
%0 should be avoided in triggers, and if left alone lists all matches.
{ } embed a raw regular expression, matches are stored to %1-%99.
%!{ } embed a raw regular expression, matches are not stored.
[ ] . + | ( ) ? * are treated as normal text unlessed used within
braces. Keep in mind that { } is replaced with ( ) automatically
unless %!{ } is used.
Of the following the (lazy) match is available at %1-%99
%w match zero to any number of word characters.
%W match zero to any number of non word characters.
%d match zero to any number of digits.
%D match zero to any number of non digits.
%s match zero to any number of spaces.
%S match zero to any number of non spaces.
%? match zero or one character.
%. match one character.
%+ match one to any number of characters.
%* match zero to any number of characters.
%i matching becomes case insensitive.
%I matching becomes case sensitive (default).
ESCAPE
------
\a beep the terminal.
\c send a control character, \ca for ctrl-a.
\e start an escape sequence.
\n send a line feed.
\r send a carriage return.
\t send a horizontal tab.
\x print an 8 bit character using hexadecimal, \xFF for example.
\x7B send the '{' character.
\x7D send the '}' character.
\u print a 16 bit unicode character, \uFFFD for example.
\U print a 21 bit unicode character, \U02AF21 for example.
\v send a vertical tab
COLOR CODES
-----------
with x, y, z being parameters
Parameter 'x': VT100 code
0 - Reset all colors and codes to default
1 - Bold
2 - Dim
4 - Underscore
5 - Blink
7 - Reverse
8 - Skip (use previous code)
Parameter 'y': Foreground color
Parameter 'z': Background color
0 - Black 5 - Magenta
1 - Red 6 - Cyan
2 - Green 7 - White
3 - Yellow 8 - Skip
4 - Blue 9 - Default
For xterm 256 colors support use to for RGB foreground
colors and to for RGB background colors. For the grayscale
foreground colors use to , for grayscale background colors
use to .
The tertiary colors are as follows:
- Azure - Jade
- Violet - Lime
- Pink - Orange
Example: #showme Azure Jade Violet
Example: #showme Lime Pink Orange
For 12 bit truecolor use to for foreground colors and
to for background colors.
For 24 bit truecolor use \e[38;2;R;G;Bm where R G B are red/green/blue
intensities between 0 and 255. For example: \e[37;2;50;100;150m. Use
\e[48;2;R;G;Bm for background colors.
HELP
----
[ ] Argument is optional.
< > Argument is required.
{ } Argument is literal.
| Used to separate arguments with multiple options.
tt/docs/tintin19.txt 0000664 0601750 0601001 00000026662 13557431253 014140 0 ustar eigenaar None
ooooooooooo ooooo oooo oooo ooooooooooo ooooo oooo oooo
88 888 88 888 8888o 88 88 888 88 888 8888o 88
888 888 88 888o88 888 888 88 888o88
888 888 88 8888 888 888 88 8888
o888o o888o o88o 88 o888o o888o o88o 88
ooo ooo
888 888
oooo888oooo oooo888oooo
888 888
888 888
Original documentation by Peter Unold
Table of Contents
-----------------
1) What is TinTin++? .............................
2) Giving Credit Where Credit is Due .............
3) Starting TinTin++ .............................
3) Basic Features ................................
4) Connecting to a MUD ...........................
5) Split Screen ..................................
6) Aliases .......................................
7) Actions .......................................
8) Highlights ....................................
9) Speedwalk .....................................
10) Tickers .......................................
11) Command Files .................................
12) Command History ...............................
13) Path Tracking .................................
14) Advanced Features .............................
15) Help ..........................................
T I N T I N ++
(T)he K(I)cki(N) (T)ick D(I)kumud Clie(N)t
========= What is TinTin++? =========
TinTin++ is a client program specialized to help playing muds. This is a
souped up version of TINTIN III with many new features.
========= Giving Credit Where Credit is Due ========
None of this work would be possible, without the work done by Peter Unold.
He was the author of TINTIN III, the base of TinTin++. Hats off to ya
Peter, You started the ball rolling.
========= Starting TinTin++ =========
The syntax for starting tintin is: ./tt++ [command file]
Read more about the command file in the 'files' section below. Remember
one thing however. All actions, aliases, substitutions, etc, defined when
starting up TinTin++ are inherited by all sessions.
If you want to get out of tintin after starting it type: #end or press
ctrl-d. If you want to paste text use shift-insert, text is automatically
copied upon selection.
======== Basic Features =========
I'll start by explaining some of the very basic and important features:
All TinTin++ commands starts with a '#'. (can be changed with #config)
Example: #help -- #help is a client command, and isn't send to the mud.
All TinTin++ commands can be abbreviated when typed.
Example: #he -- Typing #he is the same as typing #help
All commands can be separated with a ';'.
Example: n;l green;s;say Dan Dare is back! -- do these 4 commands
There are several ways ';'s can be overruled.
Example: \say Hello ;) -- Lines starting with a '\' aren't parsed by
tintin.
Example: say Hello \;) -- The escape character can esape 1 letter.
======== Connecting to a Mud =========
Command: #session {session name} {mud address} {port} {filename}
Example: #session bob tintin.sf.net 4321
You can have more than one session, in which case you can switch between
sessions typing #.
You can get a list of all sessions by typing: #session.
Providing a filename is optional.
======== Split Screen =========
Command: #split
The split command will create a separated input and output area. This
allows you to see the entire line that you are typing, without having
the mud scroll your text off the screen, or breaking up the line.
Using the #prompt command you can capture the prompt and place it on the
split line. To get rid of the split interface you can use #unsplit which
will restore the terminal settings to default.
========= Aliases =========
Command: #alias
Usage: #alias {name} {commands}
Use this command to define aliases. The variables %0, %1.. %99 contain
the arguments to the aliases-command as follows:
the %0 variable contains ALL the arguments.
the %1 variable contains the 1st argument
the %2 variable contains the 2nd argument
....
the %99 variable contains the 99th argument
Example: #alias nice say Hello Mr %1
If there are no variables on the right-side of the alias definition, any
arguments following the aliases-command will be appended to the command
string.
Example: #alias ff cast 'fireball' -- 'ff bob' equals: cast 'fireball' bob
If you want an alias to execute more commands, you must use braces.
Example: #alias ws {wake;stand}
To delete an alias use the #unalias command.
TinTin++ doesn't baby sit, and will not check for recursive aliases! You
can avoid recursion by escaping the entire line so it is send directly to
the mud.
Example: #alias put \put %1 in %2
========= Actions =========
Command: #action
Usage: #action {action-text} {commands}
Actions, also known as triggers, are used to define an action to take
place when a particular text appears on your screen. There are 99
variables you can use as wildcards in the action-text. These variables
are %1, %2....%9, %10....%98, %99.
Examples:
#action {You are hungry} {get bread bag;eat bread}
#action {%1 has arrived.} shake %1 -- shake hands with people arriving.
#action {%1 tells you '%2'} {tell bob %1 told me '%2'} -- forward tells
to Bob.
#action {tells you} #bell -- beep the terminal when you get a tell.
You can have tintin ignore the actions if you type '#ignore action on'.
You can see what commands TINTIN executes when an action triggers, by
typing '#debug action on'.
You can remove actions with the #unaction command.
========= Highlights =========
Command: #highlight (remember you can abbreviate commands)
Usage: #high {text} {color}
This command works a bit like #action. The purpose of this command is to
substitute text from the mud with color you provide. This command is a
simplified version of the #substitute command.
Examples:
#high {Snowy} {light yellow} -- colors the word Snowy.
#high {%1Snowy%2} {light yellow} -- colors a line containing Snowy
Use #unhigh to delete highlights.
========= Speedwalk =========
If you type a command consisting ONLY of numbers and the letters n, e, s,
w, u, d - then this command can be interpreted as a serie of directions
you want to go to.
Example: ssw2n -- go south, south, west, north, north
If you have problems with typing some commands that actually ONLY consists
of these words, then type them in CAPS. For example when checking the NEWS
or when asked to enter NEW as your name.
You must enable speedwalking with: #config speedwalk on
========= Tickers =========
Command: #ticker {name} {commands} {seconds}
Every 60 seconds on a standard dikumud a so called tick occures. You
regenerate faster hp/mana/mp if you're sleeping/resting during a tick. So
it's pretty nice to know when the next tick occurs. TinTin++ helps you
with that.
#ticker {tick} {#show TICK!!!;#delay 50 #show 10 SECONDS TO TICK!} {60}
This creates a ticker with the name {tick} which will print TICK!!!, as
well as print a warning when the next tick will occure.
Use #untick to delete tickers.
========= Command Files =========
When you order TinTin++ to read a command file, tintin parses all the
text in the file. You can use command files to keep aliases/actions in,
login to a mud(name, password etc..) and basically all kinds of commands.
You can make the command files with either a text editor (strongly
suggested), or use the #write command to write out a file.
Commands for files:
#read filename -- read and execute the file.
#write filename -- write all actions/aliases/substitutes known for the
current session to a file.
When you use #session you can tell it to read a command file with the 4th
argument.
Example: #session bob tintin.sf.net 4321 bobthemage.tin
========= Command History =========
If you want to use your command history you have 2 options. If you gave
Mashiranou a 4 lines long tell about the weather or something, but she
was AFK, and 15 minuts later she comes back to the keyboard and you want
to give her the exact same message you would type: !tell mashiran
TinTin++ will search through your command history for the command
starting with 'tell mashiran' and execute it.
Another slightly more flexible option is typing control-r which will
display the reverse search prompt. Simply type in a substring of a
command previously entered and it will keep showing matches till you
find the command you are looking for.
========= Path Tracking =========
Tintin tries to keep track of your movement. That is whenever you type
either north/south/east/west/up/down, tintin will push the direction and
it's opposite direction into a queue (the path) if '#path new' has been
used.
Commands for path:
#path new -- start path mode, and resets queue.
#path end -- stop path mode.
#path map -- show the path
#path ins {forward} {backward} -- insert commands into the queue
#path del -- forget last move in the path
#path save {f|b} {alias} -- save the path to the given alias
#path load {alias} -- load a path alias into the map queue
#path walk {forward|backward} -- walk 1 step forward or backward of a queue.
#action {Alas, you cannot go that way.} {#path del}
real life example.. tatataaaa:
You want a fast run to the master mindflayer and back. You go to the dump
and type: #path new. Then you run down and kill the master. To go back you
just type: #path save backward tmp;$tmp
You could of course just as well have recalled out of there, but... Hell
it's just an example.
========= Advanced Features =========
Command: #run {name} {shell command}
#run lets you run any console application interactively inside tintin.
Learning how to use tintin will not only allow you to customize and
automate a telnet connection, but any console application can be
enhanced with triggers.
========= Help =========
Command: #help {subject}
The help command is your friend, and also contains the most up to date
information of all available tintin commands. If you type #help without
an argument you will see the various help subjects, most of which aren't
described in this manual since it only covers the basics to get you
started.
Enjoy
tt/FAQ 0000664 0601750 0601001 00000012741 13631007441 011302 0 ustar eigenaar None This document will hopefully answer most questions regarding tintin++ (tt++).
Last updated: 03/07/2020
Q00) I'm new to tintin, how do I get started?
A00) Quite easy, start tintin using tt++ or ./tt++, to connect to a mud type:
#session
The name can be whatever you want it to be. If you start up 2 or more
sessions you can switch between the sessions using # or use
# [command] to have that session execute a command keeping the
session in the background.
Type #help for a list of help subjects, #help for more
information.
Q01) What machines does tintin work on?
A01) Pretty much any UNIX machine with a modern compiler as well as Windows,
Mac OS X, Android, and iOS.
Q02) What version should I use 1.50 or 1.86 or 2.00 ?
A02) TinTin++ 2.00 is twice the size of 1.86 with over 90% of the 1.86 code
rewritten. TinTin++ 2.00 is not backward compatible with 1.50 or 1.86.
The NEWS file contains all known compatibility issues.
Q06) I can't get tintin compiled. Where can I get more help?
A06) See the INSTALL file.
Q07) I still can't get tintin compiled?
A07) See the install section on the website for even more detailed help.
A pre-compiled binary is only available for Windows.
Q08) I would like to help, how can I contribute to tintin?
A08) You can assist people on the discord channel and give bug reports or
suggestions. A link to the beta version is available on the forum
in the Beta Testing section, beta testing is very important to the
continued development of TinTin++.
TinTin++ is mostly a solo project and over 95% of the code has been
written by Igor van den Hoven. If you however feel the need to
contribute a code snippet it should be released into the public
domain, this to avoid weird situations where someone who contributed
0.1% of the code demands 50% of the ownership.
Another useful way to contribute is by working on tutorials, or
writing interesting scripts for others to use.
Q09) Tintin is so awesome, how can I thank you guys for spending all that time
to write tintin for free??
A09) Fan mail and donations are always welcome :)
Q11) Can I use code from tintin?
A11) Yes, provided that you follow the terms of the license. The license
used for tintin 1.86 till tintin 2.01.7 is GPL 2 and the license as of
tintin 2.01.8 is GPL 3. TINTIN III and TinTin++ 1.5 are public domain,
meaning there are no restrinctions whatsoever.
The TinTin++ 1.5 official documentation by Robert Ellsworth was
explicitly not released into the public domain, and subsequently it
wasn't included in the GPL 2 and 3 tintin releases.
Q12) I contributed code X, why isn't my name listed in the CREDITS file?
A12) Most likely your name slipped by before Davin Chan started
maintaining tintin and adding people to the CREDITS file. If you
believe you have contributed code to tintin, please email me and
let me know. Make sure to see if your code is still existent in this
version as little of the original code has remained.
Q14) I've seen some nifty code and would like to use it in a different program.
A14) If you read the COPYING file you will see you are allowed to modify and
redistribute this version as long as you make it clear you made changes,
and what those changes are. If you want to use tintin code in another
program not licensed under GPL 3 you need permission from the author.
Make sure to see if the exact code you want to use isn't existent in older
tintin++ versions before contacting me, because I obviously cannot give
permission for code I didn't write :) Also notice that older tintin++
versions are not licensed under the GPL.
Q15) My old script files do not work, is this a bug?
A15) Possibly, more likely your old script files do not work because a lot has
changed. Try reading #help about the subject. Also the new
script parser more closely resembles the working of common scripting
languages. Also try to look through the examples, they are supposed to
work, and you might find out what you are doing wrong. Feel free to
ask for help on the forum.
The NEWS file lists most compatibility issues.
Q16) #prompt {string} does not work
A16) That's because the new syntax is: #prompt {string} {substitution}
Read the help for the substitute command for more information.
Q17) I want to make an ALIAS that creates an ACTION, but both use %0, how to
go about this?
A17) Use %%0 %%1 %%2 for the arguments of the nested action.
Q18) How to enable support for chinese muds?
A18 Use: #config charset ? to get a list of support character sets.
Q19) I use Mac OS X and ran tintin a few times, now every time I open a terminal
window, it runs tintin automatically.
A19) You clicked "use settings as default" while running tintin. There's a few
ways out of this, but the easiest is locating your terminal preference
(home : library : com.apple.Terminal.plist) and deleting it. You'll have
to redo anyting custom you set up (screen size, colors, etc.), but it
will get the terminal back to the default of loading into your home
directory.
Q20) What is the recommended terminal emulator?
A20) TinTin++ is being developed to work properly with xterm.
Q21) What is the recommended font?
A21) The default unicode settings are configured to work with Consolas and the
mintty terminal for the Windows build.
tt/INSTALL 0000664 0601750 0601001 00000002156 13612377312 012006 0 ustar eigenaar None INSTALLATION
------------
Installation should be easy; cd to the src/ directory, then type:
./configure
make install
If this went without errors or serious warnings type this to start tintin:
tt++
You might need to install the following libraries:
pcre: pcre.org
zlib: zlib.net
gnutls: gnutls.org
If you have any trouble with installing/compiling tintin you should check out
the install section on the website.
https://tintin.mudhalla.net/install.php
If that doesn't do the trick you can ask for assistance on the forum.
TERMINAL EMULATION
------------------
In order to run tintin full featured you will need a vt100 emulator. If your
OS doesn't use one per default it's suggested to install xterm.
STATIC LINKING
--------------
This is more so a note to myself to statically link PCRE on Cygwin.
$ wget ftp://ftp.csx.cam.ac.uk/pub/software/programming/pcre/pcre-8.34.tar.bz2
$ tar xvf pcre-8.34.tar.bz2
$ cd pcre-8.34/
$ ./configure CC=i686-pc-mingw32-gcc CXX=i686-pc-mingw32-g++ --enable-jit --enable-unicode-properties --disable-shared
$ make
$ ./configure --libdir='../pcre-8.34' --includedir='../pcre-8.34'
tt/mods/ 0000750 0601750 0601001 00000000000 13657574175 011723 5 ustar eigenaar None tt/mods/0.3.mods 0000664 0601750 0601001 00000007412 13517052306 013100 0 ustar eigenaar None 10/6/1992 TINTIN III
TINTIN III is a mud client special designed to help
dikumudders. It runs under various UNIX implementations.
This third release of TINTIN contains a bunch of new
features, which I hope you'll enjoy. I know that there're
many TINTINIII beta versions around. I'd advice the people
running these, to get a copy of the final release of
TINTIN-III, coz the various BETA versions are pretty buggy.
BTW thanks to the beta testers for their great support.
People used to TINTIN v2.0 shouldn't have too many trouble
with this version. But do notice anyway, that there has been
a bunch of syntax changes:
THE V2.0 COMMANDFILES ARE NOT COMPATIBLE WITH THIS V3.0!!!!!!!
TINTIN and the future
This was the last time I'll release a totally rewritten TINTIN
code. Although new versions of TINTIN might occure, they'll
be of the format ver.3.x, and will only be released if new
bugs are found and/or portability problems with this version
can be fixed. People are invited to release clones of TINTIN
if they feel they've added something neat. If you release an
extended version of TINTIN, THEN MAKE SURE TO INCLUDE YOUR
NAME IN THE TITLE-TEXT! This way I hope we can avoid nasty
parallel-versions. I might code a tintin with a X-windows
interface tho.
TINTIN and bugs
Well I might have left a bug or two around, but nothing fatal
I hope. Should you find any bugs(and debug'em too *HURRAY*)
then please lemmie know..
TINTIN and portability
TINTIN v3.0 has succesfully been compiled and run under these
UNIX-implementations:
SunOS
HPUX
Sequent
AIX
DEC ULTRIX
VAX with ULTRIX 4.1
NeXT
and some more....
If you have trouble with compiling under your system, and you
know how to fix it, then please gimmie a mail.
Makefile for TINTIN III
I'm using GNU's gcc compiler. The most important is that the
compiler is ANSI-compatible. If gcc isn't installed on your
system, then try change the 'gcc' below to 'cc' If CC = gcc
Some people's ANSI-compiler somehow don't have the full
ANSI-defined standard-library. Uncomment the lines below
if your compiler don't have 'strstr' F1 = -DDUNNO_strstr
If you recive lots of error from the 'echo.c' file, then try
to uncomment the next line: F2 = -DDO_TERMIO
Somehow people using Sun and gcc have to redefine the values
for the macros TIOCGETP and TIOCSETP. This is really dirty
coding and shouldn't be nercessary(but it is sometime).
1/4/1992 T I N T I N
(T)he K(I)cki(N) (T)ick D(I)kumud Clie(N)t
(hell I simply wanted it to be called TINTIN....)
This client is more or less a byproduct from a robot-player
prog I'm coding at the moment. This means that the prog. don't
has the same amount of features that progs like PMF and
tinymugys have(weird features that you don't use anyway...).
The prog has however some features special designed to diku-mud
that might make it interesting for you. The prog is UNIX only..
tt/mods/1.5.mods 0000664 0601750 0601001 00000035332 13517042504 013104 0 ustar eigenaar None 1/25/95 Added #split functionality, in case screen size
autodetection doesn't work. Added #purist mode:
in #split mode, commands typed at the bottom window
are not echoed in the top window too. Diddled with
the ./configure, Makefile, install.sh, gripe stuff in
hopes of making it a bit more portable.
1/5/95 Added string comparison capability to #if; format is
#if {[string1=string2]} ...
Thanks to jes3659@gold.acns.fsu.edu (Jeff Sandler)
for the code! Changed: ivars.c -- daw
1/5/95 Added else to #if command; new format is
#if {expression} {then-cmd} [ else {else-cmd} ]
where stuff inside [ ] is optional. Thanks to
Greg Jarman for the code!
Changed: ivars.c -- daw
1/5/95 Added SOCKS #ifdefs as requested by Jim Goddard
; now people who want
to use SOCKS can define the -DSOCKS part of
Makefile.in. This is only intended for the clueful
user. Changed: Makefile.in main.c parse.c -- daw
1/5/95 Added FreeBSD bug fixes kindly submitted by Andrew
Chernov ache@astral.msk.su.
Changed: main.c misc.c net.c parse.c utils.c configure
configure.in -- daw
1/4/95 Fixed all the bugs on the bigbuglist: mostly easy
(but important) portability fixes. Added autodetection
of screen size for #split mode. Added autodetection
when screen is resized (i.e. with an xterm). Added: scrsize.c
Changed: main.c rl.c Makefile.in Makefile -- daw
10/26/94 Made ! and ^d behave more like the old tintin. Hopefully
fixed bug with #zap logging people out. Fixed history
expansion so it only expands on lines that begin with !.
Added redraw, according to #redraw (only in #unsplit mode).
Added echoing of each command in #split mode. Decided
that echo.c is now useless. Deleted: echo.c
Changed: rl.c rlhist.c -- daw
10/25/94 Changed to readline 2.0. Fixed a few bugs; there were
still spaces before #defines, and still an ANSI function
declaration left over from pl6, and I made a dumb mistake
in the Makefile which I fixed. Added a compile script;
hope it's convenient and durable. Fixed bug where tt++
got in an infinite loop if it never connected.
New files: install, src/readline/*
Changed: README, INSTALL, Makefile.in, help.c, aliases.c,
net.c and maybe a few more. -- daw
10/24/94 Added readline support. Now works in both #split and
#unsplit modes -- but better in #split. Added history
expansion and whatnot. Rewrote the tab stuff, fixed
the bugs, and added #tabsave command. Fixes the bug
with keystrokes getting dropped because of raw mode.
No longer need echo.c and associated unportabilities
(I think). Rewrote the ticker, because alarms() and
readline don't seem to like each other. [It was doing
an alarm() every second anyways! ] Fixed loop
in the Makefile. Made lotsa random changes throughout
the code to get it to coexist happily with readline.
Probably lots of bugs left to fix. :-( Still need to
write docs for all this. :-(
New files: rl.c rltab.c rlhist.c rlvt100.c rltick.c log.c
Changed: main.c parse.c misc.c utils.c ticks.c and maybe more.
-- daw
8/28/94 Patch 6: Fixed to use Autoconf which makes installation
alot more easier. Also fixed help.c so it works better.
(David Hedbot, neotron@lysator.liu.se)
Changed: All files, more or less.
7/21/94 Patch 5: Fixed compile errors for HP-UX users. HP-UX likes
to use their own structure name conventions which differs
slightly from SYS V conventions. Placed a few #if's for (HPUX)
and the rest is history. Compiles like a champ now :-).
Makefile totally re-written to elieviate the common questions
asked about compiling. New script called gripe added. Helps
us in determining what you have when you have a problem. If a
problem occurs during compile, just type gripe and follow the
instructions. Mail will be sent to the devel team
automatically.
(JE/DW)
Changed: echo.c main.c tintin.h Makefile install.sh gripe
7/10/94 Patch 4: Fixed #return once and for all. The moves were being
placed back onto the path list when you did a return
That's a BIG NONO. Linked List bug fixed (priority vairable
was being assigned improperly). Help file corrections and
README changed to hopefully help users out more.
.tintinrc now shows the proper pathdirs, to allow #return to
play nicely with the rest of the program. Makefile now
calls the install script copying the helpfile automatically
to the home directory (If users don't like it, we'll know).
(JE)
Changed: llist.c path.c tintin.h docs/tintin15.*
5/13/94 Patch 3: fix for speedwalking. Tintin will no longer
go apeshit on text like "u7"; Also changed llist.c
and glob.c. Made pre-decalrations and function
declarations conform to K&R C. (See 4/20/94 for
how new functions should look) (JE)
Changed: llist.c, parse.c, tintin.h, glob.c
4/30/94 Patch 2: fix for #action {^%0 foo}; removed memory
leak in insert_history(); added #toupper and #tolower;
added the help text for #variable, which was somehow
inadvertently left out; a few minor #includes added.
Thanks you Spencer Sun and Harald Evensen! (DW)
4/27/94 Patch 1: no error message shown if ~/.tintinrc can't
be found; if can't find ./tab.txt look for ~/tab.txt;
changed help so that the helpfile can go into a
non-world-writeable directory; #showme is now tested
for actions; bug fix -- it would sometimes coredump
upon exiting session. (JE)
4/25/94 Fixed bug in insertnode_list. #action {zzzz} {foo} {0}
was guaranteed to delete all actions in the list that
had priority 1 or higher because a ->next pointer was
getting set to NULL when it should have been set to point
to the rest of the list. Affects llist.c. (DW)
4/24/94 Fixed logging so that all ^M's were removed before writing
to the log. This can be changed back to the origional
type of logging, by modifying tintin.h (OLD_LOG).
Changed: main.c, tintin.h (JE)
4/24/94 Changed part of Dave's modification to session.c. I
have been getting messages (and experiencing myself), cores
when you try to open a "sign" session, which shows a sign
then closes the session. Problem being though, for some
reason, even though a pointer may exist of (char *),
and the length of the string is 0, free cores. Being that
Mem fixes like this can take a long time, I've fudged it for
now, in that it won't free up pointers that have strlen's of
less than 1.
Changed: session.c (JE)
4/24/94 Fixed -v option and changed a couple of notification
messages in action.c and alias.c, basically just making
a couple more messages lower case and less annoying.
Changed: action.c, alias.c, files.c (BR)
4/22/94 Fixed highlighting to make it backwards compatible, 1-32
should now be valid fields for highlighting, there is
a little more that can be done to speed up highlighting a
bit. Not critical, we'll see how this works.
Changed: highlight.c (BR)
4/20/94 Nothing major, just re-wrote Dave's function declaration
for his stop signal trapper. Converted it to the convention
we have been using since 1.2:
(name of args)
;
;
;
{
}
Changed: main.c (JE)
4/19/94 Minor plug to a memory leak in session_cleanup. It
never killed all the linked lists associated with
actions, aliases, sub, highlights, etc, so I added
that. Also changed kill_all so that it deletes stuff
from the path lists, too. Also, kill_all was made to
remove lists completely if session was being killed
(kill_all used to reinitialize the list.) Now it only
initializes IF mode CLEAN is sent to kill_all. If
END is sent, then it removes and does not re-initialize
the list.
Changed: llist.c, session.c (DW/JE)
4/19/94 Bug fix to searchnode_list: it assumed that linked lists
were in alphabetical order, but as this assumption is now
invalid, the function needed a small change. Files
affected: llist.c. Doesn't affect the speed of action
matching on lines that come from the mud!! (JE/DW)
4/17/94 Bug fix to the wildcard matching in search_list_with_wild.
#unaction {* foo} removed all actions, when it obviously
shouldn't. Also added backslash recognition to escape
asterisks. This change affects #action, #alias, #sub,
and their corresponding #un commands. [Maybe more.]
llist.c, Makefile, .tt_help.tar.Z changed; glob.c added. (DW)
4/14/94 Quick fix to the session delete code to remove a minor
memory leak. session.c was the only file changed. (DW)
4/11/94 Added #tabadd and #tabdelete. Adding of words to the tab
completion list are done to the end of the list. #tabdelete
just searches the list for the word designated, and deletes it
from the list. Also corrected a bug that I found in my tablist
routine. The complete tablist wasn't being displayed.
edited files: files.c, parse.c, misc.c (JE)
4/10/94 Added #cr command. Useful for sending carriage returns to
different sessions. You would do something like #grim {#cr}.
main.c, parse.c, misc.c were edited..(JE)
4/9/94 Ohh.. forgot to mention.. another new command is #killall.
It'll nuke just about every list related to a session. Now
you don't have to exit tintin++ to load up a new set of
coms. (JE)
4/8/94 Fixed the double-echoing bug that bit you when tintin++ was
suspended and then resumed. Added a SUSPEND command, which
simply acts just as though you had typed control-z at the
keyboard. Anyone wanna test this thang on a SysV machine?
I only have access to SunOS today, and god only knows if
signal() and friends are compatible...
Also added a fix to the way aliases and their parameters
are expanded. Brace grouping used to be ignored for aliases
but now it has an effect. Try these commands
#alias foo {#showme $1; #showme $2; #showme $3}
foo testing {testing 125}
and compare between the new and old versions.
Finally, I added #include back into tintin.h.
Who removed that? Grr... :-) The affected files were
main.c, parse.c, tintin.h, and .tt_help.txt.Z. (DW)
4/1/94 Made Tintin++ think by itself! (April Fools!!! Sorry.. I
had to get that in :-) Anyways, Here are the final changes
for this revision. First off, the Makefile has been
completely re-written, adding to it clean and install. Also
added was the TEXTIN command, and fixed it so that Jeremy's
path commands worked (added PATHDIR). A few more compilation
bugs were removed, and some install scripts were written.
Time to go BETA with this pup now. (JE)
3/8/94 Made numberous bug fixes. Eliminated the bug with #split and
no argument. Fixed #sys to work on most (if not all) system.
The bug was, that the user would receive an alarm call and the
user would still be at the prompt. Hopefully, this is fixed.
People using SGI machines and Linux please get back to me on
this one. You were the ones having the most problems. #loop
now accepts large numbers as well.
Added a new command called #info. It allows the user to get
some statistical information about their current session.
Added a compiler option called -DDEBUG. It turns all alarms
off. The tickcounter won't work, but hey.. You're not playing
with this flag set. It's so gdb will work properly. (JE)
2/2/94 Rewrote insertlist_node in llist.c. Added a mode switch to
the parameters (as well as the additional priority field for
the listnode). Mode PRIORITY will insert the node onto the
list according to the priority the node was given (0 highest
pritority, 9 lowest). Mode ALPHA will insert nodes
alphabetically. Thinking was that if the node appears
closer to the head of the list, the action would react sooner.
All inserts were changed throughout the code.
Rewrote searchnode_list_begin in llist.c as well, to take care
of searches based on priority or alphabetically stored lists.
All searchs were modified throughout the code.
Added #retab, which allows the user to re-load tab.txt. All
I do is just make another call to read_complete(). Rather
simple and effective.
Added #tablist, which will display all the words in the
tab completion list. (in order from beginning to end).
Modified help.txt to accomodate the changes I've made as of
now. Once all changes are complete, I'll re-modify help.txt
(JE)
1/24/94 Moved the ignore variable to the session struct. Now
the #ignore command is isolated within a session. (i.e.
you can have one session ignored, and one session not)
The default is now set to DEFAULT_IGNORE in new_session. (JCJ)
1/19/94 Rewrote path.c to take a different set up. Rewritten to
a link list structure. Added #pathdir command. Upped
mesvar to size 7 with mesvar[6] being #pathdir. Wrote
fixed array style linked list as well, but not
implemented. Added addnode_list to file.c to add a node
to the end of a list (not in lexicographical order as
insertnode_list does). Implemented pathdir using the
listnode struct, but it does not use the char *right.
This can be improved. Perhaps with the completenode
struct. (JCJ)
1/10/94 Rewrote the highlight parse functions to a) not use the
ends and tails, b) use the color names instead of the
numbers, c) allow multiple types to the first arg. (JCJ)
6/1/93 TINTIN++ V1.0 beta test version
New commands since tintin3
#antisubstitute
#gag
#loop
#message
#map
#savepath
#variable
#highlight
#math
#togglesubs
#presub
#showme
maybe more...
This version has fixed a few bugs with the original tintin
code as well as the older tt++ versions. Highlighting now
works correctly and is much more powerful. Subs and actions
are faster, and work better. There was also a bug in the
#alias statement, look in tintin.doc for more info.
I have definitely created some new bugs with all of the new
stuff I added since 0.9 and I'm sorry for any inconvenience.
Please report bugs to me, and I'll endeavor to fix them.
I'm sorry for any delay on bug fixes from old versions, but
I thought this version would be done much sooner, and the
bugs were fixed in this version.
Bill Reiss (reiss@eggo.csee.usf.edu)
tt/mods/1.8.mods 0000664 0601750 0601001 00000147532 13517132523 013116 0 ustar eigenaar None 1999-2001 Davin Chan
--------------------
6/21/01 Release tintin v1.85. -- dsc
6/8/01 Added a #show_pretick command. This will toggle on/off
the #10 SECONDS TO TICK message, but it will still show
the #TICK message.
Changed: main.c, rltick.c, tintin.h, include/main.h,
include/misc.h, misc.c, parse.c -- dsc
5/13/01 Removed the include/Makefile and include/Makefile.in.
Deleted: include/Makefile, include/Makefile.in
Changed: configure.in -- dsc
5/13/01 Added a TINTIN_HISTORY enviroment variable to set the
location of the .tt_history file.
Changed: main.c, rl.c -- dsc
5/13/01 Removed the -Iinclude from the Makefile.in and cleaned up
referances to protos.
Changed: Makefile.in, all .c files -- dsc
5/13/01 Added a check for an enviroment variable called TINTIN_CONF
so that tintin will check for the tt.conf file at that
location before checking for it in your home directory.
Changed: chat.c -- dsc
5/13/01 Renamed the send_file command to tt_send_file to avoid
a name conflict under AIX. Thanks to Yoon-Chan Jhi for
pointing it out.
Changed: chat.c, parse.c, include/chat.h -- dsc
4/3/01 Fixed the newline string that tintin sends. It really
should be \r\n. Thanks to Emil Isberg for pointing
that out. Left in the broken_telnet thing but I'm
hoping it isn't needed anymore as tintin was sending
out the wrong newline sequence.
Changed: net.c -- dsc
3/28/01 Updated the FAQ.
Changed: FAQ -- dsc
3/17/01 Renamed all of the protos directory to include and renamed
all the proto files to .h. Updated all the .c files to
reflect the change and updated the Makefile.in.
Changed: all files -- dsc
3/17/01 Changed the BUFFERSIZE to 2048. And fixed the hard coded
values in the protos to use the BUFFERSIZE value.
Changed: tintin.h, protos/main.proto, protos/function.proto
-- dsc
2/25/01 Commented out the SIGWINCH line in main.c that was
spamming some people (appears to be only sun users).
Need to investigate this when I some time.
Changed: main.c -- dsc
12/29/00 Fixed some warnings messages by gcc with -Wall enabled.
Changed: help.c, files.c, ivars.c, main.c, misc.c,
path.c, rl.c, ticks.c -- dsc
12/29/00 Updated the readline.sh slightly to reflect the use
of --includedir and --libdir instead of having
to modify the Makefile.
Changed: readline.sh -- dsc
12/28/00 Fixed a few warnings that appear on sun machines. And
replaced usage of bzero with memset and assorted clean ups.
Changed: scrsize.c, chat.c, net.c -- dsc
12/26/00 Released tintin v1.84. It's been a while since my
last release. Pushing this out the door so that
people can make use of some of the fixes. There
are some rough spots that I need to tidy up, but
there shouldn't be any problems. -- dsc
12/26/00 Updated the FAQ file.
Changed: FAQ -- dsc
12/26/00 Added a toggle to enable and disable the saving of
history. The command is #savehistory. This will
need to be intergrated into the configuration file.
Changed: main.c, misc.c, rl.c, tintin.h,
protos/misc.proto, protos/rl.proto -- dsc
12/26/00 Fixed it so that tt.conf is looked for in the user's
home directory instead of the current directory. The
tt.conf file and the .tintinrc files need to be merged
at some point so that there is only one configuration
file.
Changed: chat.c -- dsc
12/17/00 Removed some debug statements in the #ifstrequal command.
Changed: ivars.c -- dsc
12/13/00 Added in saving of history. Tintin will write out a
.tt_history file to your home directory and read that
back in the next time you start up tintin. Keep in mind
that it will write everything you enter as a command,
including your character's password. You can do a
#clearhistory to delete all the history as well. I'll
probably make the saving of history optional as some
may be parnoid and some may not have alot of space in their
home directory to save a history of commands. Feedback
on the usefulness of this feature would be welcome.
Changed: main.c, tintin.h, rl.c -- dsc
11/07/00 Hmm, tintin regressed in respect to the broken_telnet fix.
Seems that the fix for muds that wanted only \n instead of
the standard \n\r was lost. I've reintergrated the fix, but
I guess it really doesn't affect most users since it's been
missing since 1.81.
Changed: net.c -- dsc
11/07/00 Updated the install-sh script to reflect the change in the
name of the chat.conf file to tt.conf. tt.conf will be
a generic tintin configuration file. It's purpose will
be to store custom configurations of tintin.
Changed: install-sh
Renamed: chat.conf -- dsc
11/07/00 Slight update to the INSTALL file to make it more clear on
compiling tintin with non-standard locations of readline.
Changed: INSTALL -- dsc
11/07/00 Put in a #include for stat.h that is needed for sun machines
that wasn't needed on my linux box.
Changed: chat.c -- dsc
10/09/00 Relocated the chat.conf file to the src/support directory
and updated the install-sh script to reflect that.
Changed: install-sh
Moved: chat.conf -- dsc
10/09/00 Fixed the problem with + - in the math function that
was reported by Kuang-che Wu. Let me know if the #math
function does anything strange. The original (buggy) math
is still available via the #fixedmath toggle, but by default
it will use correct math.
Changed: ivars.c -- dsc
10/03/00 Updated the install-sh script so that it will install the
chat.conf file in the same location as your tintin helpfile.
Changed: install-sh -- dsc
10/03/00 Updated the FAQ and added some comments to the chat.conf
file.
Changed: FAQ, chat.conf -- dsc
10/02/00 Added a new configure option, --enable-big5. This allows
users to select Big5 encoding without needing to manually
edit the Makefile.
Changed: configure.in, Makefile.in, INSTALL -- dsc
10/02/00 Small update to the FAQ file.
Changed: FAQ -- dsc
09/27/00 Cleaned up chat.c some. Removed some un-needed header
files. Mac OS X can compile tintin now.
Changed: chat.c -- dsc
09/27/00 Added misc patches by Kuang-che Wu.
Changed: misc.c, rl.c, net.c -- dsc
09/27/00 Added support for Big5 encoding. This has not been
tested by myself nor do I have any method of testing it.
This was sent to me by Kuang-che Wu. Current, you need
to manually edit the Makefile to have a -DBIG5 to the DEFINES
line. If you have language specific patches, I will be
willing to add them as well, but you must provide me with
the code to be be added.
Changed: action.c, parse.c, variables.c, functions.c -- dsc
09/16/00 Fixed the typo with the checking for ncurses and curses.
Changed: configure.in -- dsc
09/10/00 Replaced DST_NONE with 0 as not all machines have that
defined.
Changed: chat.c -- dsc
09/07/00 Released tintin v1.83 -- dsc
09/07/00 Made it so that tintin will check first for termcap, then
check for curse and then for ncurse. Hopefully that will
resolve the problem some people having with the tgetent.
Changed: configure.in -- dsc
09/07/00 tintin will check for a TINTIN_HELP environment variable.
This will allow you to get tintin to check a shared tintin
help file. All you need to do is to set the TINTIN_HELP
variable to the directory your help file is located.
Changed: help.c -- dsc
09/06/00 Found a error with the install-sh script. The script would
FAIL. Fixed the problem with it.
Changed: install-sh -- dsc
09/03/00 Corrected a bug with the #random function. asd@scene-hu.com
provided the one line fix.
Changed: misc.c -- dsc
08/26/00 Corrected a bug with the install.sh script. There was
a typo in the installing gzip version of the help files.
Decided that the dl directory isn't needed in the tintin++
directory. Users should create a dl or change the download
location in the chat.conf file.
Changed: install.sh
Deleted: dl directory -- dsc
08/25/00 Fixed the problem of HP-UX not linking because of the
order of the libraries. Put -lreadline before everything
else. Also put in -lhistory for the history stuff. It
seems that my compiler isn't as picky as others and allowed
me to link without the -lhistory.
Changed: Makefile.in -- dsc
08/16/00 Released tintin v1.82 -- dsc
08/16/00 Movied the MODIFICATIONS and MOD.ycjhi files into the docs
directory.
Moved: MODIFICATIONS, MOD.ycjhi -- dsc
08/16/00 Added a FAQ file. Hopefully it will answer some of the most
commonly asked questions.
Added: FAQ -- dsc
08/12/00 Added an ENABLE field to the chat.conf file. It is enabled
by default, but you can turn off the chat feature by setting
the value of ENABLE to 0. There still isn't all that much
error checking with the chat features, which will be
corrected in the future.
Changed: main.c, rl.c, chat.c -- dsc
07/25/00 Cleaned up all the warnings in chat.c.
Changed: chat.c -- dsc
07/21/00 Updated the .tt_help.txt file with the new chat commands.
Also added in a helpversion entry, this just lists the date
the helpfile was last modified to track which version of
the helpfile that is installed. Make sure you do a make
install to update your help files.
Changed: support/.tt.help.txt.Z -- dsc
07/20/00 With the addition of chat, the encryption code that I hacked
together is really not needed. I've removed the code for it
as chat looks to be a nicer command than my ugly encrypt code.
If people really want it, let me know and I'll put it back
in, but I don't think it's really needed.
Changed: misc.c, protos/misc.proto, parse.c -- dsc
07/20/00 chat has been added. This is very similiar to using an instant
messager program or using irc. The chat feature is compatiable
with mudmaster (or it should be). The code is by Sean Butler.
I tried to contact him about the use of his code, but could
not contact him. And I am assuming he would allow for the use
of his code unless notified otherwise. Added him to the
credit file. The code needs alot of clean up and modifications
still, but the basic functionality is all there. Currently,
it will try to figure out your IP address, unless you set
it in your chat.conf file. To start a chat, you would do
a #call . Once you have connected, you can do a
#chat . You can also do a #chatall
to send a message to everybody your connected to. Bug me to
write up some docs on it, but the commands should be pretty
straight forward (take a peek in the chat.c for a list of
commands). You can also transfer files (I personally
haven't tested it).
Added: chat.c -- dsc
Created: protos/chat.proto -- dsc
Changed: CREDITS, main.c, rl.c, parse.c -- dsc
07/16/00 Added a --libdir to configure. This is needed if you don't
have your libraries (readline) in standard library locates.
This change is kind of a hack since I need to hardcore
the -lreadline in the Makefile.in, but since you can't really
use tintin without readline, having it hardcoded isn't a
problem. Need to play with autoconf more to see if there
is a better solution.
Changed: configure.in, Makefile.in, INSTALL -- dsc
07/06/00 Added a #clearhistory command. This will clear out your
history of commands entered.
Changed: parse.c -- dsc
07/06/00 Added a BUG and TODO file. This is to let everybody know
what I think are bugs and what I plan on working. If you have
any input on bugs or things you would like to see added to
tintin, feel free to let me know.
Added: BUGS, TODO -- dsc
07/05/00 Worked some on the bindkey command. It doesn't do anything
really, but I spent some time playing with readline and now
have a better idea of how to get it to work.
Changed: bindkey.c, protos/bindkey.proto -- dsc
06/23/00 Fixed a bug with the #read and #newread. They both
would fail if your command file contain any blank lines.
Changed: files.c -- dsc
06/23/00 I've decided to move the #read command now to be
#newread and move the #oldread back as the default #read
command. If you wish to use the multi-line code, use the
#newread command. After it's been tested a while, I will
make it the default #read command.
Changed: parse.c, files.c, protos/files.proto -- dsc
06/23/00 Added in the fixes for functions submitted by Kaung-che Wu.
Functions still need work though.
Changed: variables.c, protos/variables.proto, function.c -- dsc
06/22/00 Cleaned up the install-sh script a bit.
Changed: install-sh -- dsc
06/22/00 Played more and now you can select the default directory
tt++ is put. It will default to the src directory. Like
the --includedir, you change the bindir by doing a
./configure --bindir=.
Example:
You want to put tt++ in ~/bin
./configure --bindir=~/bin
make
make install
Changed: Makefile.in, configure.in, INSTALL -- dsc
06/22/00 I've played with the autoconf some and made some improvements
to it. If you put readline in a non-standard directory
(ie not in /usr/local/include), you can specify that with
./configure --includedir=.
For example, if you put the readline library in say
tintin/src/readline. Then in the tintin/src directory,
you can do a ./configure --includedir=. (current directory).
Another example, if you put readline in /tmp/readline,
you can do a ./configure --includedir=/tmp
As you need to put in the parent directory of the readline
directory.
Changed: Makefile.in, configure.in, INSTALL -- dsc
06/19/00 I've added some missing code for functions that
was submitted by Kuang-Che Wu.
Changed: llist.c, files.c -- dsc
06/18/00 I've enabled the fixed_math by default now. This probably
will not affect most tintin users, but if you use / or *
you may be affected and may want to either change your
script or to use the #fixedmath to disable it.
Changed: tintin.h -- dsc
06/18/00 Put in a fix to a crash bug with verbatim when you don't
have a session. Thanks to Kuang-che Wu for the bug
report and fix.
Changed: parse.c -- dsc
06/18/00 Made a fix to the #message command. It was not listing out
the different message toggle-ables and made some slight
improvements to it.
Changed: misc.c -- dsc
06/18/00 Did further testing and I found a work around. I'll look
into this problem further when I get a chance, but the
working will allow people to use the #crypt and #decrypt
functions. Added an example of how to make use of it
in the docs/example1.script file. Somebody probably can
write a something better, but it does work. If anybody
wants to write better examples (with explainations) I
would be happy to include them. Also if you use it, you
may want to disable the variable messages (#message variable
off) to reduce the spam (it is on by default). -- dsc
06/09/00 Modified the #crypt and #decrypt functions. They currently
used a fixed key, but will change that soon. I had to change
the way it was set up because I was trying to do it the lazy
way and use the ASCII character set table. The old function
mostly worked, but for some keys it would give you funky
results.
The work around noted in the previous entry does not work.
I will need to fix the bug for these commands to be useful.
The problem is in the parser.
Changes: misc.c -- dsc
06/03/00 Added a #crypt and a #decrypt function for "encrypting" text.
I remember seeing a tintin script that did this ages ago
on the newsgroup. I decided to implement the code into
tintin. Although shortly this code will not be so useful
with the incoming chat feature, but this feature might be
fun to use to annoy imms with *polishes his halo* :)
It's extremely simple, but it should be more than enough to
ensure nobody that you don't want to read the text will.
The syntax is:
#crypt
#decrypt
Currently, the key used to encrypt the data is a fixed key,
but will add in a feature to change the key.
This works fine except I seem to hit a bug when testing
the feature. The bug is that tintin will substitutue
everything in an alias with multiple commands
#alias {ereply} {#crypt {$$0} {bleh}; reply $bleh}
however
#alias {ereply}
{#unvar {$bleh} #crypt {$$0} {bleh}; reply $bleh}
will work fine.
I will probably fix this bug at a future date, but it looks
to be a bit mess/large change to fix in a critical function.
And it would be far to easy to introduce new bugs there.
Changed: misc.c, protos/misc.proto, parse.c -- dsc
05/29/00 Added the option of stripping the binary in the install-sh
script. Striping will produce a smaller execuatable, but it
makes it harder to debug. But most people will not need to
debug tintin and would probably want to strip tt++.
Changed: install-sh -- dsc
05/29/00 *cough* hacked a*cough* Fix to the issue #2 (see 5/5/00 entry)
with the new read_command(). The read_command function will
ignore any line that starts with a "#nop" and will not parse it
so it will not care about unbalanced braces. I probably will
look for a better fix/rewrite the code in the future. This
should resolve all the problems with the read_command.
Changed: files.c -- dsc
05/27/00 Put in Yoon-Chan Jhi's fix to the syserr(). This should solve
solve the problem some people have with compiling tintin.
Changed: utils.c -- dsc
05/23/00 Made a few some modifications to the configure.in script to
hopefully make it more informative when running ./configure.
Changed: configure.in -- dsc
05/05/00 Fixed the problem with the read_command() not taking
commands with no arguments (ie #fixedmath).
Changed: files.c -- dsc
05/05/00 Ran dos2unix on the example2.script. This solves part
of the problem, with the new read_command(), but still
have the following issues. 1) it will not allow
unbalanced braces in #nop. 2) it will not take commands
with no arguments (ie #fixedmath).
Changed: docs/example2.script -- dsc
05/05/00 Modified the translate_telnet_protocol() to be a void
function. There really isn't a need for it to return
anything.
Changed: net.c, protos/net.proto -- dsc
04/30/00 Released tintin v1.81. I want to push it out now or else
it would probably be another 3+ weeks and I've promised to
put this out within a week or two (and it's been like 2 1/2
weeks now). -- dsc
04/30/00 Tracked down a problem I was having connecting to a mud
server. tintin was just kicking me out at the same point.
This was due to a change in the read_mud_buffer to use
the new translate_telnet_protocol(). I've put in a fix for
it, but I'll probably redo the fix later.
Changed: net.c -- dsc
04/30/00 Made a bug fix to the read_command function. If your
command file only contained a "#ses {l} {localhost 4000}"
It wasn't connecting when you started up tintin or when
you #read your command file.
Changed: files.c -- dsc
04/29/00 I've included the sample tintin command file that Greg
Milford sent me as it's a nice demostration of how to use
tintin. This may be useful to people in learning how to
make the best use of tintin.
Created: docs/example2.script (the script by Greg)
Renamed: docs/example.script to docs/example1.script -- dsc
04/29/00 I've intergrated a change to the read_command function by
Greg Milford. The change allows for multi-line command
files. See the docs/example.script for how it will look.
The only downside to the change is that you must use braces
ie #alias a {say blah} will not work, you need to do
#alias {a} {say blah}. The read_command will try to recover
from commands that are not written correct by ignore it and
everything after the error and then return to tintin.
So if you have 10 aliases and tintin says that it read in 5
aliases, then tintin didn't like your 6th aliases you wrote
and you should go check it. I've kept the old #read command
as #oldread if you really want to use that, but it will
probably be removed at a future date.
Changed: files.c, protos/files.proto, CREDITS,
docs/example.script -- dsc
04/29/00 I've updated the tintin help file so that it now includes
all the tintin commands. Some of the tintin help files are
a *cough* bit sparse, but they are now listed :) I still
need to update the manual and some of the entries in the
tintin help file needs to be expanding (just a tinnie bit ;))
Changed: support/.tt_help.Z -- dsc
04/12/00 Put in Yoon-Chan Jhi's change to #ifmatch. The only real
change is that it no longer has an else keyword. This
matchs the syntax of other tintin commands.
Changed: ivars.c -- dsc
04/09/00 Cleaned up some warning.
Changed: walk.c, session.c -- dsc
04/09/00 I've added an example.script in the tintin/docs directory.
This includes some basic examples (which I will expand on
when I have more time) and it includes Yoon-Chan Jhi's
auto reconnect script.
Created: docs/example.script -- dsc
04/09/00 I've put in all of Yoon-Chan Jhi's changes which includes
a zMud-like slow walk function (I don't know, I never used
zMud before), an auto reconnect feature. I'm testing them
to make sure I've gotten everything that he submitted to me
working correctly There were alot of changes and hopefully
some changes didn't slip by me. I've made some minor
modifications to his code, but they were very limited
at this point. (Don't ask me what they were, cuz I don't
remember :))
Created: walk.c, protos/walk.proto
Changed: net.c, session.c, tintin.h, parse.c -- dsc
04/08/00 Put in Yoon-Chan Jhi's change to connect_mud so that the
error messages would be more helpful than just couldn't
connect. Didn't know about the strerror() till now.
Learned something :)
Changes: net.c -- dsc
04/08/00 It's amazing what you can learn if you read :) According,
to man (3) bcopy, bcopy has been deprecated. So that explains
why some compilers give you those problems when compiling
with the -O2 flag. This was chitchat's suggestion on how
to solve the problem, but I wasn't comfort just commenting
out the use of a function to silence a compiler warning. But
on further research saw that bcopy was deprecated. In light
of that, I've added back in -O2 flag and I've removed the
use of bcopy. I've also updated the configure script to
stop checking for bcopy since it isn't used anymore.
Changes: Makefile.in, tintin.h, configure -- dsc
04/08/00 Added chitchat and Yoon-Chan Jhi to the credits file for
their contributions to tintin.
Changes: CREDITS -- dsc
04/05/00 I've added in ycjhi's change to read_buffer_mud, which
fixes the problem with tintin sometimes eating a
character after getting an GA. As a note the GA
sequence will send a \n in tintin to solve an
occassion problem with actions not being triggered.
The code, except for minor modifications, were done by
Yoon-Chan Jhi.
Changes: net.c, protos/net.c -- dsc
04/05/00 Changed the tickset command so that the code and
the manual both agree with each other. According
to the manual tickset will turn on the timer if it's
not on, but the code doesn't do that. Now it will.
This is minor, but the code and manual should agree
with each other, or what's the point of the manual if
it's wrong?
Changed: ticks.c -- dsc
04/03/00 Changed the ticksize command so that you will need to
enter a number between 1 and 1000. You previous could
crash tintin because it would try to divide by 0. There
isn't any reason why you would want to set your ticksize
to zero unless you wanted to crash tintin :P So 1 to 1000
should be a suitable range. Let me know if there is a reason
why you would want to have anything outside that range.
Changed: ticks.c -- dsc
03/08/00 Added a bindkey.proto and a bindkey.c file for the
future bindkey command. This will be for binding keys to
a command. ie #bindkey {f1} {}. This doesn't do
anything yet.
Created: bindkey.proto and bindkey.c -- dsc
02/23/00 Fixed a bug with the parsing of input. It would display the
wrong value, but the result is correct.
If you did the following:
#var {a} {1}
#math {a} {$a+1};#showme $a
This would show you 1 and not 2. The value stored in $a is
correct, but it would display 1. It will now show the correct
value 2. Thanks to aladrin@elven.comm.au for the bug report.
Changed: parse.c, protos/parse.proto -- dsc
02/23/00 Removed the -ansi flag from the Makefile and removed the
declaration of popen and pclose and made asorted cleanup
of things that were hacks/bad ideas.
Changed: Makefile.in, protos/help.proto, misc.c -- dsc
02/19/00 Added in the brokentelnet value to the #info command.
02/12/00 Released tintin v1.80 -- dsc
02/12/00 Verified that the fix for CR/LF worked on the test mud listed
on the webboard.
02/09/00 I think I corrected the problem with CR/LF with certain muds.
Please let me know if I did/or didn't. Do a #brokentelnet
to enable it to test.
Changed: net.c, misc.c, main.c, parse.c, protos/misc.proto,
protos/main.proto -- dsc
12/26/99 Updated the README and the doc/sgi files
Changed: README, doc/sgi -- dsc
12/26/99 Increased the buffer for #textin for people that need to
read in a large text file. Didn't increase all buffers
since that may be a waste of memory, but for #textin you
may need more than 1024 so I've increased it to 4096.
Problem was brought to my attention by chitchat's ytin.
Changed: text.c -- dsc
12/26/99 Fixed the math command completely (I think, let me know
if i'm wrong). You *MUST* have #fixedmath 1 set for
you to use the new math, or else it will continue to use
the old broken math. Eventually, this will be the default
but for now, you will have to enable it. Fix came
from chitchat's ytin. With the fixed math, you will
get 4 from #math {a} {6/3*2}. With the old math, you
will get 1 from #math {a} {6/3*2}.
Changed: ivars.c, protos/ivars.proto -- dsc
12/21/99 Ahh, gotta love short-circuit evalation :) Fixed a
crash bug. If you did a #message 1, it will crash.
It's fixed now. Who says it doesn't pay to be lazy? :)
Changed: misc.c -- dsc
12/19/99 Added Fixed Math to the #info output.
Changed: misc.c -- dsc
12/18/99 Added a new command to enable and disable the math
code (will also be used for priority on math symbols when
I add in that code). THE DEFAULT IS TO USE THE BROKEN
CODE. To enable the fixed math code do a #fixedmath.
Eventually, I will make it default to fixedmath on, but
for now, I'll keep it at off.
Changed: main.c, parse.c, misc.c, protos/main.proto,
protos/misc.proto -- dsc
12/18/99 Looked at the #math {x} {$x+1} problem. I've decided
to just return an error instead of initializing the
undefined variable to 0. No answer is better than a wrong
answer in my opinion. If tintin automatically creates a
variable, typos would create new variables and people would
wonder why it kept failing. This way, there is no doubt,
that something is wrong with the math expression. This
should save people time trying to debug their scripts
looking for why their math call always returns the same
(wrong) value.
#math {x} {$x+1} -> old math will create and set x to zero
-> new math will error and not create a
variable
Changed: ivars.c, protos/ivars.proto -- dsc
12/17/99 Added a sanity check for values entred for #sleep, #timetry
#tries.
Changed: misc.c -- dsc
12/17/99 Added in the code for #sleep. The syntax is #sleep